hydra-kernel 0.17.1 → 0.17.2

raw patch · 169 files changed

+7823/−2349 lines, 169 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +173/−118
• hydra-kernel.cabal +26/−14
• src/main/haskell/Hydra/Adapt.hs +7/−6
• src/main/haskell/Hydra/Analysis.hs +1/−0
• src/main/haskell/Hydra/Annotations.hs +3/−2
• src/main/haskell/Hydra/Arity.hs +1/−0
• src/main/haskell/Hydra/Checking.hs +37/−64
• src/main/haskell/Hydra/Classes.hs +1/−0
• src/main/haskell/Hydra/Codegen.hs +6/−5
• src/main/haskell/Hydra/Constants.hs +1/−4
• src/main/haskell/Hydra/Decode/Error/Core.hs +30/−0
• src/main/haskell/Hydra/Decode/Regex.hs +199/−0
• src/main/haskell/Hydra/Decoding.hs +2/−1
• src/main/haskell/Hydra/Dependencies.hs +1/−0
• src/main/haskell/Hydra/Differentiation.hs +1/−0
• src/main/haskell/Hydra/Dsl/Analysis.hs +2/−0
• src/main/haskell/Hydra/Dsl/Annotations.hs +4/−2
• src/main/haskell/Hydra/Dsl/Arity.hs +2/−0
• src/main/haskell/Hydra/Dsl/Checking.hs +5/−38
• src/main/haskell/Hydra/Dsl/Constants.hs +2/−4
• src/main/haskell/Hydra/Dsl/Dependencies.hs +2/−0
• src/main/haskell/Hydra/Dsl/Environment.hs +2/−0
• src/main/haskell/Hydra/Dsl/Error/Core.hs +257/−0
• src/main/haskell/Hydra/Dsl/Extract/Json.hs +2/−0
• src/main/haskell/Hydra/Dsl/Formatting.hs +2/−0
• src/main/haskell/Hydra/Dsl/Json/Decode.hs +3/−1
• src/main/haskell/Hydra/Dsl/Json/Decoding.hs +2/−0
• src/main/haskell/Hydra/Dsl/Json/Encode.hs +3/−1
• src/main/haskell/Hydra/Dsl/Json/Parser.hs +2/−0
• src/main/haskell/Hydra/Dsl/Json/Writer.hs +2/−0
• src/main/haskell/Hydra/Dsl/Json/Yaml/Decode.hs +2/−0
• src/main/haskell/Hydra/Dsl/Json/Yaml/Encode.hs +2/−0
• src/main/haskell/Hydra/Dsl/Lexical.hs +4/−2
• src/main/haskell/Hydra/Dsl/Lib/Chars.hs +16/−0
• src/main/haskell/Hydra/Dsl/Lib/Eithers.hs +47/−0
• src/main/haskell/Hydra/Dsl/Lib/Equality.hs +11/−0
• src/main/haskell/Hydra/Dsl/Lib/Functions.hs +103/−0
• src/main/haskell/Hydra/Dsl/Lib/Lists.hs +132/−0
• src/main/haskell/Hydra/Dsl/Lib/Literals.hs +2/−0
• src/main/haskell/Hydra/Dsl/Lib/Logic.hs +2/−0
• src/main/haskell/Hydra/Dsl/Lib/Maps.hs +27/−0
• src/main/haskell/Hydra/Dsl/Lib/Math.hs +2/−0
• src/main/haskell/Hydra/Dsl/Lib/Optionals.hs +48/−0
• src/main/haskell/Hydra/Dsl/Lib/Pairs.hs +2/−0
• src/main/haskell/Hydra/Dsl/Lib/Regex.hs +2/−0
• src/main/haskell/Hydra/Dsl/Lib/Sets.hs +11/−0
• src/main/haskell/Hydra/Dsl/Lib/Strings.hs +36/−0
• src/main/haskell/Hydra/Dsl/Names.hs +2/−0
• src/main/haskell/Hydra/Dsl/Predicates.hs +2/−0
• src/main/haskell/Hydra/Dsl/Print/Docs.hs +129/−0
• src/main/haskell/Hydra/Dsl/Reduction.hs +4/−2
• src/main/haskell/Hydra/Dsl/Refs.hs +2/−0
• src/main/haskell/Hydra/Dsl/Regex.hs +436/−0
• src/main/haskell/Hydra/Dsl/Resolution.hs +3/−1
• src/main/haskell/Hydra/Dsl/Rewriting.hs +2/−0
• src/main/haskell/Hydra/Dsl/Scoping.hs +2/−0
• src/main/haskell/Hydra/Dsl/Serialization.hs +2/−0
• src/main/haskell/Hydra/Dsl/Show/Docs.hs +0/−127
• src/main/haskell/Hydra/Dsl/Sorting.hs +2/−0
• src/main/haskell/Hydra/Dsl/Strip.hs +2/−0
• src/main/haskell/Hydra/Dsl/Test/Transform.hs +2/−0
• src/main/haskell/Hydra/Dsl/Test/Utils.hs +3/−1
• src/main/haskell/Hydra/Dsl/Variables.hs +2/−0
• src/main/haskell/Hydra/Dsls.hs +1/−0
• src/main/haskell/Hydra/Encode/Error/Core.hs +43/−0
• src/main/haskell/Hydra/Encode/Regex.hs +165/−0
• src/main/haskell/Hydra/Encoding.hs +1/−0
• src/main/haskell/Hydra/Environment.hs +1/−0
• src/main/haskell/Hydra/Error/Core.hs +46/−0
• src/main/haskell/Hydra/Extract/Core.hs +45/−44
• src/main/haskell/Hydra/Extract/Json.hs +1/−0
• src/main/haskell/Hydra/Extract/Util.hs +2/−1
• src/main/haskell/Hydra/Formatting.hs +1/−0
• src/main/haskell/Hydra/Hoisting.hs +1/−0
• src/main/haskell/Hydra/Inference.hs +32/−42
• src/main/haskell/Hydra/Json/Decode.hs +4/−3
• src/main/haskell/Hydra/Json/Decoding.hs +1/−0
• src/main/haskell/Hydra/Json/Encode.hs +5/−4
• src/main/haskell/Hydra/Json/Parser.hs +1/−0
• src/main/haskell/Hydra/Json/Writer.hs +1/−0
• src/main/haskell/Hydra/Json/Yaml/Decode.hs +1/−0
• src/main/haskell/Hydra/Json/Yaml/Encode.hs +1/−0
• src/main/haskell/Hydra/Kernel.hs +2/−2
• src/main/haskell/Hydra/Languages.hs +1/−0
• src/main/haskell/Hydra/Lexical.hs +6/−5
• src/main/haskell/Hydra/Lib/Chars.hs +56/−0
• src/main/haskell/Hydra/Lib/Defaults.hs +359/−0
• src/main/haskell/Hydra/Lib/Effects.hs +88/−0
• src/main/haskell/Hydra/Lib/Eithers.hs +350/−0
• src/main/haskell/Hydra/Lib/Equality.hs +49/−0
• src/main/haskell/Hydra/Lib/Files.hs +1/−0
• src/main/haskell/Hydra/Lib/Functions.hs +240/−0
• src/main/haskell/Hydra/Lib/Hashing.hs +1/−0
• src/main/haskell/Hydra/Lib/Lists.hs +568/−0
• src/main/haskell/Hydra/Lib/Literals.hs +1/−0
• src/main/haskell/Hydra/Lib/Logic.hs +1/−0
• src/main/haskell/Hydra/Lib/Maps.hs +132/−0
• src/main/haskell/Hydra/Lib/Math.hs +1/−0
• src/main/haskell/Hydra/Lib/Optionals.hs +362/−0
• src/main/haskell/Hydra/Lib/Pairs.hs +1/−0
• src/main/haskell/Hydra/Lib/Regex.hs +1/−0
• src/main/haskell/Hydra/Lib/Sets.hs +53/−0
• src/main/haskell/Hydra/Lib/Strings.hs +124/−0
• src/main/haskell/Hydra/Lib/System.hs +77/−0
• src/main/haskell/Hydra/Lib/Text.hs +1/−0
• src/main/haskell/Hydra/Literals.hs +1/−0
• src/main/haskell/Hydra/Names.hs +1/−0
• src/main/haskell/Hydra/Overlay/Haskell/Dsl/Prims.hs +2/−2
• src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Phantoms.hs +25/−2
• src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Testing.hs +6/−6
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Chars.hs +8/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Effects.hs +9/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Eithers.hs +21/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Equality.hs +4/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Functions.hs +22/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Lists.hs +69/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Maps.hs +12/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Optionals.hs +23/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Sets.hs +5/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Strings.hs +19/−0
• src/main/haskell/Hydra/Overlay/Haskell/Lib/System.hs +21/−0
• src/main/haskell/Hydra/Overlay/Haskell/Libraries.hs +55/−4
• src/main/haskell/Hydra/Parse/Docs.hs +70/−0
• src/main/haskell/Hydra/Parse/Regex.hs +145/−0
• src/main/haskell/Hydra/Parsers.hs +1/−0
• src/main/haskell/Hydra/Predicates.hs +1/−0
• src/main/haskell/Hydra/Print/Core.hs +536/−0
• src/main/haskell/Hydra/Print/Docs.hs +88/−0
• src/main/haskell/Hydra/Print/Emacs/Regex.hs +152/−0
• src/main/haskell/Hydra/Print/Error/Core.hs +373/−0
• src/main/haskell/Hydra/Print/Error/Packaging.hs +169/−0
• src/main/haskell/Hydra/Print/Errors.hs +215/−0
• src/main/haskell/Hydra/Print/Graph.hs +50/−0
• src/main/haskell/Hydra/Print/Paths.hs +141/−0
• src/main/haskell/Hydra/Print/Pcre/Regex.hs +153/−0
• src/main/haskell/Hydra/Print/Posix/Regex.hs +163/−0
• src/main/haskell/Hydra/Print/Regex.hs +153/−0
• src/main/haskell/Hydra/Print/Typing.hs +73/−0
• src/main/haskell/Hydra/Print/Util.hs +54/−0
• src/main/haskell/Hydra/Print/Variants.hs +86/−0
• src/main/haskell/Hydra/Read/Docs.hs +0/−69
• src/main/haskell/Hydra/Reduction.hs +4/−3
• src/main/haskell/Hydra/Reflect.hs +1/−0
• src/main/haskell/Hydra/Refs.hs +1/−0
• src/main/haskell/Hydra/Regex.hs +162/−0
• src/main/haskell/Hydra/Resolution.hs +4/−3
• src/main/haskell/Hydra/Rewriting.hs +17/−7
• src/main/haskell/Hydra/Scoping.hs +1/−0
• src/main/haskell/Hydra/Serialization.hs +1/−0
• src/main/haskell/Hydra/Show/Core.hs +0/−535
• src/main/haskell/Hydra/Show/Docs.hs +0/−87
• src/main/haskell/Hydra/Show/Error/Core.hs +0/−345
• src/main/haskell/Hydra/Show/Error/Packaging.hs +0/−168
• src/main/haskell/Hydra/Show/Errors.hs +0/−214
• src/main/haskell/Hydra/Show/Graph.hs +0/−49
• src/main/haskell/Hydra/Show/Paths.hs +0/−140
• src/main/haskell/Hydra/Show/Typing.hs +0/−72
• src/main/haskell/Hydra/Show/Util.hs +0/−53
• src/main/haskell/Hydra/Show/Variants.hs +0/−85
• src/main/haskell/Hydra/Sorting.hs +1/−0
• src/main/haskell/Hydra/Strip.hs +1/−0
• src/main/haskell/Hydra/Substitution.hs +1/−0
• src/main/haskell/Hydra/Templates.hs +2/−1
• src/main/haskell/Hydra/Test/Transform.hs +1/−0
• src/main/haskell/Hydra/Test/Utils.hs +3/−2
• src/main/haskell/Hydra/Unification.hs +4/−3
• src/main/haskell/Hydra/Validate/Core.hs +34/−1
• src/main/haskell/Hydra/Validate/Packaging.hs +5/−4
• src/main/haskell/Hydra/Variables.hs +1/−0

@@ -15,142 +15,197 @@  --- -## [0.17.1] - unreleased+## [0.17.2] - 2026-07-28 -Development version. Opens the 0.17.x line — the first release built entirely against-published 0.17.0 hosts (Hackage / PyPI / Maven Central), with the `hostOverrides` shims-that were needed while 0.16.1 lacked the effect type and I/O primitives removed.+Point release on the 0.17.x line. Themes: promotion of the generator's routing and manifest+logic into Hydra (`hydra.build.*`), per-package API-doc publishing across Java/Scala/Python,+constraint-polymorphic arithmetic, and new effectful stream/file primitives. Includes the base64+binary-literal rename `literals.binaryToString`/`stringToBinary` → `binaryToBase64`/`base64ToBinary`,+a step toward [#417](https://github.com/CategoricalData/hydra/issues/417) (which remains in progress). +### Highlights++- **Build system promoted into Hydra**: the three generator drivers now consume `hydra.build.routing`+  ([#560](https://github.com/CategoricalData/hydra/issues/560)) and `hydra.build.manifest`+  ([#607](https://github.com/CategoricalData/hydra/issues/607)), retiring the legacy static prefix+  tables; the cold-seeder oil-and-water violation is fixed+  ([#608](https://github.com/CategoricalData/hydra/issues/608)) and guarded+  ([#617](https://github.com/CategoricalData/hydra/issues/617)).+- **Per-package API docs** for all doc-bearing hosts: JavaDoc restructured with cross-links and a fixed+  tag→CI→Pages chain ([#616](https://github.com/CategoricalData/hydra/issues/616)), plus mirrored+  Scaladoc ([#619](https://github.com/CategoricalData/hydra/issues/619)) and Python API docs+  ([#620](https://github.com/CategoricalData/hydra/issues/620)).+- **Constraint-polymorphic arithmetic**: a `numeric` type class with enforcement and value-level dispatch+  ([#566](https://github.com/CategoricalData/hydra/issues/566)), reflected on the target hosts+  ([#618](https://github.com/CategoricalData/hydra/issues/618)).+ ### New features +- Standard-stream primitives: `stdin`/`stdout`/`stderr` ([#526](https://github.com/CategoricalData/hydra/issues/526)).+- Recursive flag for `hydra.lib.files.listDirectory` ([#527](https://github.com/CategoricalData/hydra/issues/527)).+- Hydra-specific regex syntax with per-target translation (`hydra.read.regex` / `hydra.show.regex`)+  ([#567](https://github.com/CategoricalData/hydra/issues/567)).+- Constraint-polymorphic arithmetic: `numeric` type class + value-level dispatch+  ([#566](https://github.com/CategoricalData/hydra/issues/566)).+- Aggregated Java + Scala Maven publishing into a single Central Portal deployment+  ([#591](https://github.com/CategoricalData/hydra/issues/591)).++### Improvements++- Generator drivers consume `hydra.build.routing` ([#560](https://github.com/CategoricalData/hydra/issues/560))+  and `hydra.build.manifest` ([#607](https://github.com/CategoricalData/hydra/issues/607)).+- Fixed the cold-seeder oil-and-water violation ([#608](https://github.com/CategoricalData/hydra/issues/608))+  and extended `check-oil-and-water.py` to catch cold-seeder imports of unpublished `Hydra.Build.*`+  ([#617](https://github.com/CategoricalData/hydra/issues/617)).+- Moved non-kernel packages to strict validation, clearing the #575 backlog+  ([#580](https://github.com/CategoricalData/hydra/issues/580)).+- Decoupled `Hydra.Sources.Test.All` from `Hydra.Sources.All`'s re-export list+  ([#601](https://github.com/CategoricalData/hydra/issues/601)).+- Renamed `hydra.json.schema` to resolve the module-vs-namespace-prefix conflict that broke+  file-per-module hosts ([#532](https://github.com/CategoricalData/hydra/issues/532)).+- Coders route `hydra.lib.*` overlay imports by overlay-module existence, not name-matching+  `hydra.lib.defaults` ([#568](https://github.com/CategoricalData/hydra/issues/568)).+- Per-package JavaDoc/Scaladoc/Python-doc publishing+  ([#616](https://github.com/CategoricalData/hydra/issues/616),+  [#619](https://github.com/CategoricalData/hydra/issues/619),+  [#620](https://github.com/CategoricalData/hydra/issues/620)).+- Aligned Java-host Scala/TypeScript generation with Haskell on expression layout (line-wrapping,+  declaration order) ([#612](https://github.com/CategoricalData/hydra/issues/612)).++### Bug fixes++- **TypeScript** — added the missing CI job (zero prior coverage)+  ([#571](https://github.com/CategoricalData/hydra/issues/571)); fixed the+  `verify-distribution.sh` smoke-test import so the gate actually gates+  ([#578](https://github.com/CategoricalData/hydra/issues/578)); emit `hydra.parse.regex`'s+  `regexSequence` before its alternation use (TS2448)+  ([#604](https://github.com/CategoricalData/hydra/issues/604)).+- **Build and sync** — `sync.sh` Phase 3 digest-cache now sees cross-package deps on moved kernel+  symbols, fixing stale downstream output ([#606](https://github.com/CategoricalData/hydra/issues/606)).+- **Numeric constraints** — `#566` polymorphism now reflected on the target hosts (targets were+  monomorphizing `int32->int32->int32`) ([#618](https://github.com/CategoricalData/hydra/issues/618)).++---++## [0.17.1] - 2026-07-18++Consolidation release on the 0.17.x line, built against published 0.17.0 hosts. Themes:+generated term-reference DSLs, a translingual package-validation framework, promotion of the+build system into Hydra (`hydra-build`), and broad TypeScript-host and cross-host hardening.++### Highlights+ - **Generated term-reference DSLs** ([#467](https://github.com/CategoricalData/hydra/issues/467)):-  kernel *term* modules now project generated DSL surfaces, completing the story begun with-  type-module DSLs and the generated primitive wrappers (`hydra.dsl.lib.*`, 0.17.0). A-  signature read-back in the DSL pass reuses the main pass's inference, and a demand-curated-  set of 19 kernel term modules (plus the json/test/extract modules) emits one typed,-  rename-safe reference per definition into every target language — e.g. Haskell-  `Hydra.Dsl.Strip.deannotateType`, Java `hydra.dsl.Strip.deannotateType(...)`, Python-  `hydra.dsl.strip.deannotate_type(...)`. The Java and Python coder sources were pivoted onto-  the generated references, retiring ~700 stringly-typed inline `var("hydra....")` references-  and shrinking Python's hand registry to the non-generatable remainder (byte-identical-  generated output before and after). Follow-ups:-  [#555](https://github.com/CategoricalData/hydra/issues/555) (typed references to derived-  encode/decode/show functions via `TypedName`),-  [#556](https://github.com/CategoricalData/hydra/issues/556) (non-kernel packages).+  kernel term modules now emit one typed, rename-safe reference per definition into every target+  language; the Java and Python coder sources were pivoted onto them, retiring ~700 stringly-typed+  inline references. - **Package validation** ([#574](https://github.com/CategoricalData/hydra/issues/574),   [#575](https://github.com/CategoricalData/hydra/issues/575)): a translingual `hydra.validate.*`-  framework carries per-package `ValidationProfile`s (error/warning rules, error/warning caps) and a-  catalog of checks — undeclared-package-dependency detection (now a fatal gate, #574),-  definition-name convention (PascalCase), definition ordering, documentation completeness, and-  conflicting-variant-name detection — layered on the existing core term/type well-formedness rules.-  A kernel-strict / others-relaxed policy keeps `/sync` green fleet-wide while the documentation-  backlog drains. See the new [Validation](https://github.com/CategoricalData/hydra/wiki/Validation)-  wiki page for the full per-package constraint specification.-- **DSL-authoring registration guards** ([#554](https://github.com/CategoricalData/hydra/issues/554)):-  fail-fast authoring-time validation for the host-native DSL sources — every DSL-authoring module in-  Java/`hydra-jvm`, Python, and Scala now asserts its definitions are fully registered-  (`Defs.checkComplete` / `check_complete`), backed by a Haskell kernel-source registration-completeness-  scanner, so a definition added to a source file but omitted from its `definitions` list fails loudly-  instead of silently vanishing from the generated output.-- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546),-  [#529](https://github.com/CategoricalData/hydra/issues/529),-  [#530](https://github.com/CategoricalData/hydra/issues/530)): the build-orchestration logic that had-  lived only in host scripts is now translingual Hydra. Pure module-list utilities became-  `hydra.build.modules` (#529) and the orphan-reconcile decision became `hydra.build.reconcile` (#530),-  each with a translingual test suite; the `hydra.build.*` modules were then extracted into a dedicated-  `hydra-build` package (#546), separate from the kernel.-- **Metadata sidecar + content/version-addressed freshness**-  ([#415](https://github.com/CategoricalData/hydra/issues/415)): dist manifests now carry a-  `moduleFormatVersion` field, and the generator's freshness basis is content/version-addressed — the-  groundwork for reproducible, cache-correct incremental generation.-- **Structured generation-provenance record**-  ([#523](https://github.com/CategoricalData/hydra/issues/523)): each generation run now records a-  structured `Generation` provenance entry (digest v2), replacing the ad-hoc shell threading of-  generation metadata.-- **Worker + issue hierarchy** ([#557](https://github.com/CategoricalData/hydra/issues/557)): a-  principled agent/worker framework — roles and parentage mirroring the GitHub issue tree, a-  cross-worktree message transport with a verify-after-copy protocol, a blocking-aware design-question-  (`decisions/`) channel, an issue-proposal queue with the `/issues` command, an autonomy-dial banner,-  and cross-machine staging coordination. Contributor-facing process only; no change to generated code.+  framework with per-package `ValidationProfile`s (undeclared-dependency gate, naming/ordering/docs+  checks). See the [Validation](https://github.com/CategoricalData/hydra/wiki/Validation) wiki page.+- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546)):+  build-orchestration logic that lived only in host scripts is now translingual Hydra+  (`hydra.build.*`), extracted into a dedicated package. -### API and usability+### New features -- **DSL usability passes** ([#430](https://github.com/CategoricalData/hydra/issues/430),-  [#553](https://github.com/CategoricalData/hydra/issues/553)): reviewed the host-native Java, Python,-  and Scala DSL surfaces for ergonomics and cross-host parity (documented def shapes, added a Scala-  projection helper), bringing the three authoring dialects into closer alignment.+- Generated term-reference DSLs ([#467](https://github.com/CategoricalData/hydra/issues/467));+  follow-ups: `TypedName` refs to derived encode/decode/show+  ([#555](https://github.com/CategoricalData/hydra/issues/555)), non-kernel packages+  ([#556](https://github.com/CategoricalData/hydra/issues/556)).+- Translingual package-validation framework ([#574](https://github.com/CategoricalData/hydra/issues/574),+  [#575](https://github.com/CategoricalData/hydra/issues/575)).+- DSL-authoring registration guards: fail-fast completeness checks for the Java/Python/Scala DSL sources+  ([#554](https://github.com/CategoricalData/hydra/issues/554)).+- `hydra-build` package: `hydra.build.modules`+  ([#529](https://github.com/CategoricalData/hydra/issues/529)), `hydra.build.reconcile`+  ([#530](https://github.com/CategoricalData/hydra/issues/530)), extracted from the kernel+  ([#546](https://github.com/CategoricalData/hydra/issues/546)).+- Effectful `hydra.lib.system` primitive library ([#498](https://github.com/CategoricalData/hydra/issues/498)).+- SHA-256 cryptographic hash primitive in `hydra.lib` ([#524](https://github.com/CategoricalData/hydra/issues/524)).+- `hydra-jvm` package: shared JVM serde helpers relocated out of `hydra.java.serde`+  ([#505](https://github.com/CategoricalData/hydra/issues/505)).+- Internalized the Hydra-TinkerPop bindings (formerly HydraPop)+  ([#442](https://github.com/CategoricalData/hydra/issues/442)).+- Compact unit-valued variants in the JSON encoding ([#520](https://github.com/CategoricalData/hydra/issues/520)).+- Structured generation-provenance record (digest v2) ([#413](https://github.com/CategoricalData/hydra/issues/413),+  [#523](https://github.com/CategoricalData/hydra/issues/523)).+- Metadata sidecar + content/version-addressed freshness (`moduleFormatVersion`)+  ([#415](https://github.com/CategoricalData/hydra/issues/415)).+- Worker + issue hierarchy: agent/worker framework, cross-worktree messaging, issue-proposal queue+  (contributor process only) ([#557](https://github.com/CategoricalData/hydra/issues/557)). -### Fixed+### Improvements -Bug fixes landed this cycle, grouped by area (see each issue for detail):+- Type inference for annotations ([#229](https://github.com/CategoricalData/hydra/issues/229)).+- Fixed the signature / definition split in primitive definitions+  ([#502](https://github.com/CategoricalData/hydra/issues/502)).+- DSL usability passes across the host-native Java/Python/Scala surfaces+  ([#430](https://github.com/CategoricalData/hydra/issues/430),+  [#553](https://github.com/CategoricalData/hydra/issues/553)).+- Audited the Scala and Lisp-family coders for the unconditional `hydra.lib.*` overlay-import rewrite+  ([#569](https://github.com/CategoricalData/hydra/issues/569)). -- **TypeScript** — reactivated `hydra.lib.*` primitive tests surfaced encoder gaps: lazy show-calling-  let bindings and compact bare-string `LiteralType` expansion in the test converter-  ([#564](https://github.com/CategoricalData/hydra/issues/564)),-  `binaryToBytes` registration + base64 binary decode in `decodeUtf8`-  ([#561](https://github.com/CategoricalData/hydra/issues/561)),+### Bug fixes++- **TypeScript host** — V8 stack budget on ts→Java ([#390](https://github.com/CategoricalData/hydra/issues/390));+  effectful libs not generated / 484 tsc errors ([#503](https://github.com/CategoricalData/hydra/issues/503));+  15 effect/file inference cases ([#504](https://github.com/CategoricalData/hydra/issues/504));+  ts→ts self-host regression ([#507](https://github.com/CategoricalData/hydra/issues/507)); npm packages+  bundling a duplicate kernel ([#584](https://github.com/CategoricalData/hydra/issues/584)); broken npm+  entry points ([#587](https://github.com/CategoricalData/hydra/issues/587));+  `hydra.test.build.modules.allTests` gen-universe gap ([#588](https://github.com/CategoricalData/hydra/issues/588)).+- **TypeScript coder** — reactivated `hydra.lib.*` tests: lazy show-calling let bindings + compact+  `LiteralType` expansion ([#564](https://github.com/CategoricalData/hydra/issues/564)); `binaryToBytes`+  registration + base64 decode in `decodeUtf8` ([#561](https://github.com/CategoricalData/hydra/issues/561));   `hydra.test.build.*` emission after the #546 split-  ([#570](https://github.com/CategoricalData/hydra/issues/570)), and `HYDRA_DEFAULT_IMPLS` support in-  the test runner ([#536](https://github.com/CategoricalData/hydra/issues/536)).-- **Tests and CI** — restored the default-primitive-implementation testing solution-  ([#388](https://github.com/CategoricalData/hydra/issues/388),-  [#549](https://github.com/CategoricalData/hydra/issues/549)), reactivated previously-ignored kernel-  test cases ([#513](https://github.com/CategoricalData/hydra/issues/513),-  [#550](https://github.com/CategoricalData/hydra/issues/550)), wired the regression harnesses into CI-  and split them out of the monolithic Haskell job for timeout headroom-  ([#535](https://github.com/CategoricalData/hydra/issues/535),-  [#563](https://github.com/CategoricalData/hydra/issues/563)), added Scala/Go/Lisp-  self-containment gates to `verify-distribution.sh`-  ([#537](https://github.com/CategoricalData/hydra/issues/537)), a manifest-JSON-tracked CI check-  ([#541](https://github.com/CategoricalData/hydra/issues/541)), a per-package test-digest freshness-  fix ([#551](https://github.com/CategoricalData/hydra/issues/551)), overlay-file restoration in-  `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)), and a-  sync-freshness fingerprint that now sees host-native DSL sources-  ([#562](https://github.com/CategoricalData/hydra/issues/562)).+  ([#570](https://github.com/CategoricalData/hydra/issues/570)); `HYDRA_DEFAULT_IMPLS` in the test runner+  ([#536](https://github.com/CategoricalData/hydra/issues/536)); overlay-import rewrite no longer captures+  `hydra.lib.defaults` ([#565](https://github.com/CategoricalData/hydra/issues/565)).+- **Lisp family** — clj→clj bootstrap hang in `generate_source_files`+  ([#479](https://github.com/CategoricalData/hydra/issues/479)); Common Lisp `test_graph.lisp` loader+  forward-reference ([#496](https://github.com/CategoricalData/hydra/issues/496)); Scheme maps+  last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)); Emacs Lisp+  bootstrap `wrong-type-argument (listp :string)` ([#586](https://github.com/CategoricalData/hydra/issues/586));+  `hydra.build.*` regeneration into the Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)). - **Kernel and coders** — Java binary-literal signed-byte emission-  ([#528](https://github.com/CategoricalData/hydra/issues/528)), `hydra.json.Decode.fromJson`-  parametric-type (Application/Forall) support-  ([#531](https://github.com/CategoricalData/hydra/issues/531)), stale 2-param `Coder` shape in-  Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552)), and a-  kernel dead-code/TODO cleanup ([#538](https://github.com/CategoricalData/hydra/issues/538)).+  ([#528](https://github.com/CategoricalData/hydra/issues/528)); `hydra.json.Decode.fromJson`+  parametric-type support ([#531](https://github.com/CategoricalData/hydra/issues/531)); stale 2-param+  `Coder` shape in Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552));+  Java Javadoc ampersand escaping ([#493](https://github.com/CategoricalData/hydra/issues/493)); Scala+  coder over-generalizing `Schema[S,T,V,E]` args, breaking `hydra-pg`+  ([#589](https://github.com/CategoricalData/hydra/issues/589)); kernel dead-code/TODO cleanup+  ([#538](https://github.com/CategoricalData/hydra/issues/538)).+- **Publishing and packaging** — self-broken 0.16.0 `hydra-kernel`/`hydra-python` wheels+  ([#472](https://github.com/CategoricalData/hydra/issues/472)). - **Lib and build** — `hydra.lib.files` copy/removeDirectory/status overlays across all nine hosts-  ([#525](https://github.com/CategoricalData/hydra/issues/525)), `hydra.build.*` regeneration into the-  Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)), Scheme maps-  last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)),-  standalone-kernel SHA dependency ([#542](https://github.com/CategoricalData/hydra/issues/542)),-  the lexicon's empty Types section ([#539](https://github.com/CategoricalData/hydra/issues/539)), and-  a duplicated generated-file header in `generate-head-haskell-build.py`-  ([#540](https://github.com/CategoricalData/hydra/issues/540)).--- **TypeScript overlay-import rewrite** ([#565](https://github.com/CategoricalData/hydra/issues/565)):-  the TypeScript coder's lib overlay-import rewrite no longer captures `hydra.lib.defaults`, which is a-  generated (not overlaid) module; excluding it fixes spurious import references in generated TypeScript.--- **Lexicon generation** (`bin/regenerate-lexicon.sh`): the generator had been failing-  silently since the encoder/decoder modules moved to in-memory synthesis-  ([#448](https://github.com/CategoricalData/hydra/issues/448)) — the script masked the-  failure and left a stale `docs/hydra-lexicon.txt` missing the four effectful primitive-  libraries (`hydra.lib.{effects,files,system,text}`). The synthesized coder modules are-  now included in the lexicon universe, the script fails loudly, and the regenerated-  lexicon covers all 267 primitives across 17 library modules.-- **`bin/prepare-release.sh`**: the non-blocking Java quality check invoked Gradle-  subprojects (`:hydra-rdf4j:test` etc.) that were removed in-  [#511](https://github.com/CategoricalData/hydra/issues/511), so it always warned without-  checking anything; it now runs the `dist/java/hydra-pg` package tests (the current home-  of the former binding tests).-- **`.gitignore`**: the ignore rules for the overlaid hand-written Haskell runtime still-  named pre-[#501](https://github.com/CategoricalData/hydra/issues/501) paths, so 41-  duplicate copies under `dist/haskell/` had become tracked; the rules now match the-  `Hydra/Overlay/` location and the duplicates are untracked.+  ([#525](https://github.com/CategoricalData/hydra/issues/525)); standalone-kernel SHA dependency+  ([#542](https://github.com/CategoricalData/hydra/issues/542)); lexicon's empty Types section+  ([#539](https://github.com/CategoricalData/hydra/issues/539)); silent lexicon-generation failure since+  the coders moved to in-memory synthesis ([#448](https://github.com/CategoricalData/hydra/issues/448));+  duplicated generated-file header in `generate-head-haskell-build.py`+  ([#540](https://github.com/CategoricalData/hydra/issues/540)); `.gitignore` untracking 41 duplicate+  overlaid-runtime copies under `dist/haskell/` ([#501](https://github.com/CategoricalData/hydra/issues/501));+  `bin/prepare-release.sh` Java quality check repointed to `dist/java/hydra-pg` tests after+  ([#511](https://github.com/CategoricalData/hydra/issues/511)).+- **Tests and CI** — restored default-primitive-implementation testing+  ([#388](https://github.com/CategoricalData/hydra/issues/388),+  [#549](https://github.com/CategoricalData/hydra/issues/549)); reactivated ignored kernel test cases+  ([#513](https://github.com/CategoricalData/hydra/issues/513),+  [#550](https://github.com/CategoricalData/hydra/issues/550)); wired + split out the regression harnesses+  ([#535](https://github.com/CategoricalData/hydra/issues/535),+  [#563](https://github.com/CategoricalData/hydra/issues/563)); Scala/Go/Lisp self-containment gates+  ([#537](https://github.com/CategoricalData/hydra/issues/537)); manifest-JSON-tracked CI check+  ([#541](https://github.com/CategoricalData/hydra/issues/541)); per-package test-digest freshness+  ([#551](https://github.com/CategoricalData/hydra/issues/551)); overlay-file restoration in+  `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)); DSL-aware+  sync-freshness fingerprint ([#562](https://github.com/CategoricalData/hydra/issues/562)).  ### Documentation -- Corrected the 0.17.0 Maven coordinates throughout (Java artifacts publish under group-  `net.fortytwo.hydra.java`, Scala under `net.fortytwo.hydra.scala`,-  [#519](https://github.com/CategoricalData/hydra/issues/519)); added the npm and Scala-  release channels to the README; added TypeScript/Scala/Lisp sections to Getting started;-  repointed stale pre-#418/#501 DSL paths in the architecture docs; added GitHub issue and-  PR templates.+- Corrected 0.17.0 Maven coordinates and added npm/Scala release channels, TypeScript/Scala/Lisp+  Getting-started sections, and issue/PR templates+  ([#519](https://github.com/CategoricalData/hydra/issues/519)).  --- 

@@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.38.1.+-- This file has been generated from package.yaml by hpack version 0.39.1. -- -- see: https://github.com/sol/hpack  name:           hydra-kernel-version:        0.17.1+version:        0.17.2 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@@ -54,6 +54,7 @@       Hydra.Decode.Parsing       Hydra.Decode.Paths       Hydra.Decode.Query+      Hydra.Decode.Regex       Hydra.Decode.Relational       Hydra.Decode.System       Hydra.Decode.Tabular@@ -105,6 +106,7 @@       Hydra.Dsl.Lib.Defaults       Hydra.Dsl.Lib.Eithers       Hydra.Dsl.Lib.Equality+      Hydra.Dsl.Lib.Functions       Hydra.Dsl.Lib.Lists       Hydra.Dsl.Lib.Literals       Hydra.Dsl.Lib.Logic@@ -120,15 +122,16 @@       Hydra.Dsl.Parsing       Hydra.Dsl.Paths       Hydra.Dsl.Predicates+      Hydra.Dsl.Print.Docs       Hydra.Dsl.Query       Hydra.Dsl.Reduction       Hydra.Dsl.Refs+      Hydra.Dsl.Regex       Hydra.Dsl.Relational       Hydra.Dsl.Resolution       Hydra.Dsl.Rewriting       Hydra.Dsl.Scoping       Hydra.Dsl.Serialization-      Hydra.Dsl.Show.Docs       Hydra.Dsl.Sorting       Hydra.Dsl.Strip       Hydra.Dsl.System@@ -161,6 +164,7 @@       Hydra.Encode.Parsing       Hydra.Encode.Paths       Hydra.Encode.Query+      Hydra.Encode.Regex       Hydra.Encode.Relational       Hydra.Encode.System       Hydra.Encode.Tabular@@ -207,6 +211,7 @@       Hydra.Lib.Eithers       Hydra.Lib.Equality       Hydra.Lib.Files+      Hydra.Lib.Functions       Hydra.Lib.Hashing       Hydra.Lib.Lists       Hydra.Lib.Literals@@ -250,6 +255,7 @@       Hydra.Overlay.Haskell.Lib.Eithers       Hydra.Overlay.Haskell.Lib.Equality       Hydra.Overlay.Haskell.Lib.Files+      Hydra.Overlay.Haskell.Lib.Functions       Hydra.Overlay.Haskell.Lib.Hashing       Hydra.Overlay.Haskell.Lib.Lists       Hydra.Overlay.Haskell.Lib.Literals@@ -265,31 +271,37 @@       Hydra.Overlay.Haskell.Lib.Text       Hydra.Overlay.Haskell.Libraries       Hydra.Packaging+      Hydra.Parse.Docs+      Hydra.Parse.Regex       Hydra.Parsers       Hydra.Parsing       Hydra.Paths       Hydra.Predicates+      Hydra.Print.Core+      Hydra.Print.Docs+      Hydra.Print.Emacs.Regex+      Hydra.Print.Error.Core+      Hydra.Print.Error.Packaging+      Hydra.Print.Errors+      Hydra.Print.Graph+      Hydra.Print.Paths+      Hydra.Print.Pcre.Regex+      Hydra.Print.Posix.Regex+      Hydra.Print.Regex+      Hydra.Print.Typing+      Hydra.Print.Util+      Hydra.Print.Variants       Hydra.Query-      Hydra.Read.Docs       Hydra.Reduction       Hydra.Reflect       Hydra.Refs+      Hydra.Regex       Hydra.Relational       Hydra.Resolution       Hydra.Rewriting       Hydra.Scoping       Hydra.Serialization       Hydra.Settings-      Hydra.Show.Core-      Hydra.Show.Docs-      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.Strip       Hydra.Substitution

@@ -38,16 +38,17 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors+import qualified Hydra.Print.Graph as PrintGraph import qualified Hydra.Query as Query import qualified Hydra.Reduction as Reduction import qualified Hydra.Reflect as Reflect+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular@@ -214,7 +215,7 @@ -- | 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)+    Optionals.cases (Maps.lookup lt litmap) (Core.LiteralString (PrintCore.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@@ -276,7 +277,7 @@                     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))))+                  _ -> Eithers.bind (tryTerm term1) (\mterm -> Optionals.cases mterm (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no alternatives for term: " (PrintCore.term term1))))) (\term2 -> Right term2))))       in (Rewriting.rewriteTermM rewrite term0)  -- | Adapt a term using the constraints of a given language@@ -322,7 +323,7 @@                     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))+                  \recurse -> \typ -> Eithers.bind (recurse typ) (\type1 -> Optionals.cases (tryType type1) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no alternatives for type: " (PrintCore.type_ typ))))) (\type2 -> Right type2))       in (Rewriting.rewriteTypeM rewrite type0)  -- | Adapt a type using the constraints of a given language

@@ -39,6 +39,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Predicates as Predicates import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Scoping as Scoping

@@ -33,10 +33,11 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular

@@ -23,6 +23,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -36,15 +36,16 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors+import qualified Hydra.Print.Variants as PrintVariants import qualified Hydra.Query as Query import qualified Hydra.Reflect as Reflect+import qualified Hydra.Regex as Regex 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.System as System@@ -71,7 +72,7 @@           t = Pairs.second uc       in (Lists.foldl (\b -> \x -> Logic.and b (Equality.equal x h)) True t)) --- | Apply type arguments to a type, substituting forall-bound variables+-- | Apply type arguments to a type, substituting forall-bound variables. Paper: inference.tex, 'Checking the witness' (consuming the pending-type-argument stack). applyTypeArgumentsToType :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Type -> Either Errors.Error Core.Type applyTypeArgumentsToType cx tx typeArgs t =     Optionals.cases (Lists.uncons typeArgs) (Right t) (\uc ->@@ -85,11 +86,11 @@         Core.TypeVariable v0 -> Eithers.either (\_ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "forall type",           Errors.unexpectedShapeErrorActual = (Strings.cat [-            ShowCore.type_ t,+            PrintCore.type_ t,             ". Trying to apply ",             (Literals.showInt32 (Lists.length typeArgs)),             " type args: ",-            (Formatting.showList ShowCore.type_ typeArgs)])})))) (\schemaRes ->+            (Formatting.showList PrintCore.type_ typeArgs)])})))) (\schemaRes ->           let schemaType = Pairs.first schemaRes               schemaBody = Strip.deannotateType (Core.typeSchemeBody schemaType)           in case schemaBody of@@ -98,16 +99,16 @@         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "forall type",           Errors.unexpectedShapeErrorActual = (Strings.cat [-            ShowCore.type_ t,+            PrintCore.type_ t,             ". Trying to apply ",             (Literals.showInt32 (Lists.length typeArgs)),             " type args: ",-            (Formatting.showList ShowCore.type_ typeArgs),+            (Formatting.showList PrintCore.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)+-- | Check that a term has no unbound type variables (Either version). Paper: inference.tex, 'Checking the witness' (always-on finalization invariant). checkForUnboundTypeVariables :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error () checkForUnboundTypeVariables cx tx term0 = @@ -141,21 +142,6 @@       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 =@@ -166,16 +152,7 @@                 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.+-- | Sanity-check a type substitution arising from unification. Specifically, check that schema types have not been inappropriately unified with type variables inferred from terms. Paper: inference.tex, 'Checking the witness' (always-on invariant: a substitution may not bind a type name as if it were an inference variable). checkTypeSubst :: t0 -> Graph.Graph -> Typing.TypeSubst -> Either Errors.Error Typing.TypeSubst checkTypeSubst cx tx subst = @@ -191,14 +168,10 @@           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))+          printPair = \p -> Strings.cat2 (Strings.cat2 (Core.unName (Pairs.first p)) " --> ") (PrintCore.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 =@@ -207,7 +180,7 @@           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.+-- | 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. Paper: inference.tex, 'Checking the witness' (effective equality). normalizeTypeFreeVars :: Core.Type -> Core.Type normalizeTypeFreeVars typ = @@ -227,7 +200,7 @@ 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+-- | Given a type context, reconstruct the type of a System F term. Paper: inference.tex, 'Checking the witness' -- the executable form of the System F typing judgment in the soundness theorem. typeOf :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOf cx tx typeArgs term = @@ -257,11 +230,11 @@         _ -> Left (Errors.ErrorChecking (Checking.CheckingErrorUnsupportedTermVariant (Checking.UnsupportedTermVariantError {           Checking.unsupportedTermVariantErrorTermVariant = (Reflect.termVariant term)}))) --- | Reconstruct the type of an annotated term (Either/InferenceContext version)+-- | Reconstruct the type of an annotated term (Either/InferenceContext version). Paper: inference.tex, rule Ann (checking side). 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)+-- | Reconstruct the type of an application term (Either/InferenceContext version). Paper: inference.tex, rule App (checking side). typeOfApplication :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Application -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfApplication cx tx typeArgs app = @@ -294,7 +267,7 @@                 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)+-- | Reconstruct the type of a case statement (Either/InferenceContext version). Paper: inference.tex, rules Case and Case_d (checking side). typeOfCaseStatement :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.CaseStatement -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfCaseStatement cx tx typeArgs cs = @@ -329,7 +302,7 @@                 Core.functionTypeCodomain = cod}),               cx3))))))))) --- | Reconstruct the type of an either value (Either/InferenceContext version)+-- | Reconstruct the type of an either value (Either/InferenceContext version). Paper: inference.tex, rules Eith_L and Eith_R (checking side). typeOfEither :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Either Core.Term Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfEither cx tx typeArgs et = @@ -362,7 +335,7 @@                 Core.eitherTypeRight = rightType}),               cx2)))) et) arityErr))))) --- | Reconstruct the type of a union injection (Either/InferenceContext version)+-- | Reconstruct the type of a union injection (Either/InferenceContext version). Paper: inference.tex, rule Inj (checking side). typeOfInjection :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Injection -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfInjection cx tx typeArgs injection = @@ -377,7 +350,7 @@             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)+-- | Reconstruct the type of a lambda function (Either/InferenceContext version). Paper: inference.tex, rule Abs (checking side). typeOfLambda :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Lambda -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfLambda cx tx typeArgs l = @@ -407,7 +380,7 @@             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)+-- | Reconstruct the type of a let binding (Either/InferenceContext version). Paper: inference.tex, rule Let (checking side). typeOfLet :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Let -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfLet cx tx typeArgs letTerm = @@ -438,7 +411,7 @@               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)+-- | Reconstruct the type of a list (Either/InferenceContext version). Paper: inference.tex, rules Lst_0 and Lst_+ (checking side). typeOfList :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> [Core.Term] -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfList cx tx typeArgs els = @@ -462,14 +435,14 @@               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)+-- | Reconstruct the type of a literal (Either/InferenceContext version). Paper: inference.tex, rule Lit (checking side). typeOfLiteral :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Literal -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfLiteral cx tx typeArgs lit =        let t = Core.TypeLiteral (Reflect.literalType lit)       in (Eithers.bind (applyTypeArgumentsToType cx tx typeArgs t) (\applied -> Right (applied, cx))) --- | Reconstruct the type of a map (Either/InferenceContext version)+-- | Reconstruct the type of a map (Either/InferenceContext version). Paper: inference.tex, rules Map_0 and Map_+ (checking side). 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 = @@ -518,7 +491,7 @@                 Core.mapTypeKeys = kt,                 Core.mapTypeValues = vt}))) (\applied -> Right (applied, cx3)))))))))))) --- | Reconstruct the type of an optional value (Either/InferenceContext version)+-- | Reconstruct the type of an optional value (Either/InferenceContext version). Paper: inference.tex, rules Opt_0 and Opt_1 (checking side). typeOfMaybe :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Maybe Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfMaybe cx tx typeArgs mt = @@ -540,7 +513,7 @@                     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)+-- | Reconstruct the type of a pair (Either/InferenceContext version). Paper: inference.tex, rule Pair (checking side). typeOfPair :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> (Core.Term, Core.Term) -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfPair cx tx typeArgs p = @@ -566,7 +539,7 @@         Checking.typeArityMismatchErrorActualArity = n,         Checking.typeArityMismatchErrorTypeArguments = typeArgs}))))) --- | Reconstruct the type of a primitive function (Either/InferenceContext version)+-- | Reconstruct the type of a primitive function (Either/InferenceContext version). Paper: inference.tex, rule Prim (checking side). typeOfPrimitive :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Name -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfPrimitive cx tx typeArgs name = @@ -581,7 +554,7 @@             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)+-- | Reconstruct the type of a record projection (Either/InferenceContext version). Paper: inference.tex, rule Proj (checking side). typeOfProjection :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Projection -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfProjection cx tx typeArgs p = @@ -601,7 +574,7 @@               Core.functionTypeCodomain = sftyp}),             cx2))))))) --- | Reconstruct the type of a record (Either/InferenceContext version)+-- | Reconstruct the type of a record (Either/InferenceContext version). Paper: inference.tex, rule Rec (checking side). typeOfRecord :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Record -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfRecord cx tx typeArgs record = @@ -619,7 +592,7 @@         let cx2 = Pairs.second foldR         in (Right (Resolution.nominalApplication tname typeArgs, cx2)))) --- | Reconstruct the type of a set (Either/InferenceContext version)+-- | Reconstruct the type of a set (Either/InferenceContext version). Paper: inference.tex, rules Set_0 and Set_+ (checking side). typeOfSet :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> S.Set Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfSet cx tx typeArgs els = @@ -647,7 +620,7 @@ 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)+-- | Reconstruct the type of a type application term (Either/InferenceContext version). Paper: inference.tex, 'Checking the witness' (pushes onto the pending-type-argument stack). typeOfTypeApplication :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.TypeApplicationTerm -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfTypeApplication cx tx typeArgs tyapp = @@ -655,7 +628,7 @@           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)+-- | Reconstruct the type of a type lambda (type abstraction) term (Either/InferenceContext version). Paper: inference.tex, type abstraction terms in the elaborated Term grammar. typeOfTypeLambda :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.TypeLambda -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfTypeLambda cx tx typeArgs tl = @@ -679,12 +652,12 @@           Core.forallTypeParameter = v,           Core.forallTypeBody = t1}))) (\applied -> Right (applied, cx2))))) --- | Reconstruct the type of the unit term (Either/InferenceContext version)+-- | Reconstruct the type of the unit term (Either/InferenceContext version). Paper: inference.tex, rule Unit (checking side). typeOfUnit :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfUnit cx tx typeArgs =     Eithers.bind (applyTypeArgumentsToType cx tx typeArgs Core.TypeUnit) (\applied -> Right (applied, cx)) --- | Reconstruct the type of an unwrap operation (Either/InferenceContext version)+-- | Reconstruct the type of an unwrap operation (Either/InferenceContext version). Paper: inference.tex, rule Unwr (checking side). 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 ->@@ -701,7 +674,7 @@             Core.functionTypeCodomain = swrapped}),           cx2))))) --- | Reconstruct the type of a variable (Either/InferenceContext version)+-- | Reconstruct the type of a variable (Either/InferenceContext version). Paper: inference.tex, rules Var and Prim (checking side); note the primitives-first lookup order, the reverse of inference. typeOfVariable :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Name -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfVariable cx tx typeArgs name = @@ -718,7 +691,7 @@         ErrorCore.untypedTermVariableErrorLocation = (Paths.SubtermPath []),         ErrorCore.untypedTermVariableErrorName = name}))) forScheme) forScheme) --- | Reconstruct the type of a wrapped term (Either/InferenceContext version)+-- | Reconstruct the type of a wrapped term (Either/InferenceContext version). Paper: inference.tex, rule Wrp (checking side). typeOfWrappedTerm :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.WrappedTerm -> Either Errors.Error (Core.Type, Typing.InferenceContext) typeOfWrappedTerm cx tx typeArgs wt = @@ -741,7 +714,7 @@           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+-- | Check whether two types are effectively equal, disregarding type aliases, forall quantifiers, and treating in-scope type variables as wildcards. Paper: inference.tex, 'Checking the witness' (effective equality, the type-level analogue of the referential-transparency equality of terms). typesEffectivelyEqual :: Graph.Graph -> Core.Type -> Core.Type -> Bool typesEffectivelyEqual tx t1 t2 =     Logic.or (containsInScopeTypeVars tx t1) (Logic.or (containsInScopeTypeVars tx t2) (typesAllEffectivelyEqual tx [

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -46,11 +46,12 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular@@ -106,7 +107,7 @@        let name = Core.unName (Packaging.primitiveDefinitionName (Graph.primitiveDefinition prim))           typ = Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim))-          typeStr = ShowCore.typeScheme typ+          typeStr = PrintCore.typeScheme typ       in (Strings.cat2 (Strings.cat2 (Strings.cat2 "  " name) " : ") typeStr)  -- | Format a term binding for the lexicon@@ -114,13 +115,13 @@ formatTermBinding binding =        let name = Core.unName (Core.bindingName binding)-          typeStr = Optionals.cases (Core.bindingTypeScheme binding) "?" (\scheme -> ShowCore.typeScheme scheme)+          typeStr = Optionals.cases (Core.bindingTypeScheme binding) "?" (\scheme -> PrintCore.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)))+    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))) " = ") (PrintCore.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]

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -34,10 +35,6 @@ 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

@@ -245,6 +245,9 @@                         Core.Name "invalidTypeLambdaParameterName",                         (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorInvalidTypeLambdaParameterName t) (invalidTypeLambdaParameterNameError cx input))),                       (+                        Core.Name "missingCaseBranches",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorMissingCaseBranches t) (missingCaseBranchesError cx input))),+                      (                         Core.Name "nestedTermAnnotation",                         (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorNestedTermAnnotation t) (nestedTermAnnotationError cx input))),                       (@@ -272,6 +275,9 @@                         Core.Name "undefinedTypeVariableInTypeApplication",                         (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUndefinedTypeVariableInTypeApplication t) (undefinedTypeVariableInTypeApplicationError cx input))),                       (+                        Core.Name "unknownCaseAlternative",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUnknownCaseAlternative t) (unknownCaseAlternativeError cx input))),+                      (                         Core.Name "unknownPrimitiveName",                         (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUnknownPrimitiveName t) (unknownPrimitiveNameError cx input))),                       (@@ -377,6 +383,18 @@           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.MissingCaseBranchesError+missingCaseBranchesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.MissingCaseBranchesError+missingCaseBranchesError 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 -> Eithers.bind (ExtractCore.requireField "variantNames" (ExtractCore.decodeList DecodeCore.name) fieldMap cx) (\field_variantNames -> Right (ErrorCore.MissingCaseBranchesError {+          ErrorCore.missingCaseBranchesErrorLocation = field_location,+          ErrorCore.missingCaseBranchesErrorTypeName = field_typeName,+          ErrorCore.missingCaseBranchesErrorVariantNames = field_variantNames})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.MissingCaseBranchesError")) (ExtractCore.stripWithDecodingError cx raw)+ -- | Decoder for hydra.error.core.NestedTermAnnotationError nestedTermAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.NestedTermAnnotationError nestedTermAnnotationError cx raw =@@ -572,6 +590,18 @@           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.UnknownCaseAlternativeError+unknownCaseAlternativeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UnknownCaseAlternativeError+unknownCaseAlternativeError 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 -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.UnknownCaseAlternativeError {+          ErrorCore.unknownCaseAlternativeErrorLocation = field_location,+          ErrorCore.unknownCaseAlternativeErrorTypeName = field_typeName,+          ErrorCore.unknownCaseAlternativeErrorName = field_name})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UnknownCaseAlternativeError")) (ExtractCore.stripWithDecodingError cx raw)  -- | Decoder for hydra.error.core.UnknownPrimitiveNameError unknownPrimitiveNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UnknownPrimitiveNameError

@@ -0,0 +1,199 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term decoders for hydra.regex++module Hydra.Decode.Regex 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.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Regex as Regex+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.regex.Alternation+alternation :: Graph.Graph -> Core.Term -> Either Errors.DecodingError [Regex.RegexSequence]+alternation = ExtractCore.decodeList regexSequence++-- | Decoder for hydra.regex.Atom+atom :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Regex.Atom+atom 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 "literal",+                        (\input -> Eithers.map (\t -> Regex.AtomLiteral 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 "any", (\input -> Eithers.map (\t -> Regex.AtomAny) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "anchorStart", (\input -> Eithers.map (\t -> Regex.AtomAnchorStart) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "anchorEnd", (\input -> Eithers.map (\t -> Regex.AtomAnchorEnd) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "group", (\input -> Eithers.map (\t -> Regex.AtomGroup t) (alternation cx input))),+                      (Core.Name "class", (\input -> Eithers.map (\t -> Regex.AtomClass t) (characterClass 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.regex.CharacterClass+characterClass :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Regex.CharacterClass+characterClass cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "negated" (\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_negated -> Eithers.bind (ExtractCore.requireField "items" (ExtractCore.decodeList classItem) fieldMap cx) (\field_items -> Right (Regex.CharacterClass {+          Regex.characterClassNegated = field_negated,+          Regex.characterClassItems = field_items}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.regex.CharacterClass")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.regex.CharacterRange+characterRange :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Regex.CharacterRange+characterRange cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "from" (\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_from -> Eithers.bind (ExtractCore.requireField "to" (\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_to -> Right (Regex.CharacterRange {+          Regex.characterRangeFrom = field_from,+          Regex.characterRangeTo = field_to}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.regex.CharacterRange")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.regex.ClassItem+classItem :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Regex.ClassItem+classItem 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 "character",+                        (\input -> Eithers.map (\t -> Regex.ClassItemCharacter 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 -> Regex.ClassItemRange t) (characterRange 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.regex.Quantified+quantified :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Regex.Quantified+quantified cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "atom" atom fieldMap cx) (\field_atom -> Eithers.bind (ExtractCore.requireField "quantifier" quantifier fieldMap cx) (\field_quantifier -> Right (Regex.Quantified {+          Regex.quantifiedAtom = field_atom,+          Regex.quantifiedQuantifier = field_quantifier}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.regex.Quantified")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.regex.Quantifier+quantifier :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Regex.Quantifier+quantifier 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 -> Regex.QuantifierOne) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "zeroOrOne", (\input -> Eithers.map (\t -> Regex.QuantifierZeroOrOne) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "zeroOrMore", (\input -> Eithers.map (\t -> Regex.QuantifierZeroOrMore) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "oneOrMore", (\input -> Eithers.map (\t -> Regex.QuantifierOneOrMore) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "exactly",+                        (\input -> Eithers.map (\t -> Regex.QuantifierExactly 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 -> Regex.QuantifierAtLeast 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 -> Regex.QuantifierRange_ t) (quantifierRange 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.regex.QuantifierRange+quantifierRange :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Regex.QuantifierRange+quantifierRange 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 (Regex.QuantifierRange {+          Regex.quantifierRangeMin = field_min,+          Regex.quantifierRangeMax = field_max}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.regex.QuantifierRange")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.regex.Regex+regex :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Regex.Alternation+regex = alternation++-- | Decoder for hydra.regex.RegexSequence+regexSequence :: Graph.Graph -> Core.Term -> Either Errors.DecodingError [Regex.Quantified]+regexSequence = ExtractCore.decodeList quantified

@@ -35,11 +35,12 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Predicates as Predicates+import qualified Hydra.Print.Core as PrintCore import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing

@@ -36,6 +36,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Sorting as Sorting

@@ -26,6 +26,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Strip as Strip import qualified Hydra.System as System

@@ -40,6 +40,7 @@ import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Predicates as DslPredicates import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Rewriting as DslRewriting import qualified Hydra.Dsl.Scoping as DslScoping@@ -70,6 +71,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Predicates as Predicates import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Scoping as Scoping

@@ -30,6 +30,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Strip as DslStrip import qualified Hydra.Dsl.System as DslSystem@@ -56,10 +57,11 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -49,6 +50,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -33,6 +33,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Resolution as DslResolution import qualified Hydra.Dsl.Rewriting as DslRewriting@@ -64,15 +65,16 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors+import qualified Hydra.Print.Variants as PrintVariants import qualified Hydra.Query as Query import qualified Hydra.Reflect as Reflect+import qualified Hydra.Regex as Regex 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.System as System@@ -122,19 +124,6 @@         Core.applicationArgument = (Typed.unTypedTerm arg1)})),       Core.applicationArgument = (Typed.unTypedTerm arg2)})) --- | DSL reference to hydra.checking.checkNominalApplication-checkNominalApplication :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Either Errors.Error ((), Typing.InferenceContext))-checkNominalApplication arg0 arg1 arg2 arg3 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermApplication (Core.Application {-        Core.applicationFunction = (Core.TermApplication (Core.Application {-          Core.applicationFunction = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.checkNominalApplication")),-            Core.applicationArgument = (Typed.unTypedTerm arg0)})),-          Core.applicationArgument = (Typed.unTypedTerm arg1)})),-        Core.applicationArgument = (Typed.unTypedTerm arg2)})),-      Core.applicationArgument = (Typed.unTypedTerm arg3)}))- -- | DSL reference to hydra.checking.checkSameType checkSameType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm String -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Either Errors.Error Core.Type) checkSameType arg0 arg1 arg2 arg3 =@@ -148,19 +137,6 @@         Core.applicationArgument = (Typed.unTypedTerm arg2)})),       Core.applicationArgument = (Typed.unTypedTerm arg3)})) --- | DSL reference to hydra.checking.checkType-checkType :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error ())-checkType arg0 arg1 arg2 arg3 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermApplication (Core.Application {-        Core.applicationFunction = (Core.TermApplication (Core.Application {-          Core.applicationFunction = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.checkType")),-            Core.applicationArgument = (Typed.unTypedTerm arg0)})),-          Core.applicationArgument = (Typed.unTypedTerm arg1)})),-        Core.applicationArgument = (Typed.unTypedTerm arg2)})),-      Core.applicationArgument = (Typed.unTypedTerm arg3)}))- -- | DSL reference to hydra.checking.checkTypeSubst checkTypeSubst :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Typing.TypeSubst -> Typed.TypedTerm (Either Errors.Error Typing.TypeSubst) checkTypeSubst arg0 arg1 arg2 =@@ -171,15 +147,6 @@           Core.applicationArgument = (Typed.unTypedTerm arg0)})),         Core.applicationArgument = (Typed.unTypedTerm arg1)})),       Core.applicationArgument = (Typed.unTypedTerm arg2)}))---- | DSL reference to hydra.checking.checkTypeVariables-checkTypeVariables :: Typed.TypedTerm t0 -> Typed.TypedTerm t1 -> Typed.TypedTerm ()-checkTypeVariables arg0 arg1 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermApplication (Core.Application {-        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.checkTypeVariables")),-        Core.applicationArgument = (Typed.unTypedTerm arg0)})),-      Core.applicationArgument = (Typed.unTypedTerm arg1)}))  -- | DSL reference to hydra.checking.containsInScopeTypeVars containsInScopeTypeVars :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -49,6 +50,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -62,10 +64,6 @@ import qualified Hydra.Variants as Variants import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci---- | DSL reference to hydra.constants.debugInference-debugInference :: Typed.TypedTerm Bool-debugInference = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.debugInference"))  -- | DSL reference to hydra.constants.ignoredVariable ignoredVariable :: Typed.TypedTerm String

@@ -32,6 +32,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Rewriting as DslRewriting import qualified Hydra.Dsl.Sorting as DslSorting@@ -61,6 +62,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Sorting as Sorting

@@ -27,6 +27,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Scoping as DslScoping import qualified Hydra.Dsl.Sorting as DslSorting@@ -57,6 +58,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Scoping as Scoping import qualified Hydra.Sorting as Sorting

@@ -948,6 +948,15 @@         Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL injection for the missingCaseBranches variant of hydra.error.core.InvalidTermError+invalidTermErrorMissingCaseBranches :: Typed.TypedTerm ErrorCore.MissingCaseBranchesError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorMissingCaseBranches x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "missingCaseBranches"),+        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 =@@ -1029,6 +1038,15 @@         Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL injection for the unknownCaseAlternative variant of hydra.error.core.InvalidTermError+invalidTermErrorUnknownCaseAlternative :: Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorUnknownCaseAlternative x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unknownCaseAlternative"),+        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 =@@ -1395,6 +1413,125 @@               Core.projectionFieldName = (Core.Name "actualType")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL constructor for hydra.error.core.MissingCaseBranchesError+missingCaseBranchesError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm ErrorCore.MissingCaseBranchesError+missingCaseBranchesError location typeName variantNames =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+      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)},+        Core.Field {+          Core.fieldName = (Core.Name "variantNames"),+          Core.fieldTerm = (Typed.unTypedTerm variantNames)}]}))++-- | DSL accessor for the location field of hydra.error.core.MissingCaseBranchesError+missingCaseBranchesErrorLocation :: Typed.TypedTerm ErrorCore.MissingCaseBranchesError -> Typed.TypedTerm Paths.SubtermPath+missingCaseBranchesErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.error.core.MissingCaseBranchesError+missingCaseBranchesErrorMissingCaseBranchesError :: Typed.TypedName ErrorCore.MissingCaseBranchesError+missingCaseBranchesErrorMissingCaseBranchesError = Typed.TypedName (Core.Name "hydra.error.core.MissingCaseBranchesError")++-- | DSL accessor for the typeName field of hydra.error.core.MissingCaseBranchesError+missingCaseBranchesErrorTypeName :: Typed.TypedTerm ErrorCore.MissingCaseBranchesError -> Typed.TypedTerm Core.Name+missingCaseBranchesErrorTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the variantNames field of hydra.error.core.MissingCaseBranchesError+missingCaseBranchesErrorVariantNames :: Typed.TypedTerm ErrorCore.MissingCaseBranchesError -> Typed.TypedTerm [Core.Name]+missingCaseBranchesErrorVariantNames x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+        Core.projectionFieldName = (Core.Name "variantNames")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the location field of hydra.error.core.MissingCaseBranchesError+missingCaseBranchesErrorWithLocation :: Typed.TypedTerm ErrorCore.MissingCaseBranchesError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.MissingCaseBranchesError+missingCaseBranchesErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+      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.MissingCaseBranchesError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "variantNames"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+              Core.projectionFieldName = (Core.Name "variantNames")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeName field of hydra.error.core.MissingCaseBranchesError+missingCaseBranchesErrorWithTypeName :: Typed.TypedTerm ErrorCore.MissingCaseBranchesError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.MissingCaseBranchesError+missingCaseBranchesErrorWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+      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.MissingCaseBranchesError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "variantNames"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+              Core.projectionFieldName = (Core.Name "variantNames")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the variantNames field of hydra.error.core.MissingCaseBranchesError+missingCaseBranchesErrorWithVariantNames :: Typed.TypedTerm ErrorCore.MissingCaseBranchesError -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm ErrorCore.MissingCaseBranchesError+missingCaseBranchesErrorWithVariantNames original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+      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.MissingCaseBranchesError"),+              Core.projectionFieldName = (Core.Name "location")})),+            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.core.MissingCaseBranchesError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "variantNames"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+ -- | DSL constructor for hydra.error.core.NestedTermAnnotationError nestedTermAnnotationError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTermAnnotationError nestedTermAnnotationError location =@@ -2577,6 +2714,126 @@             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.UnknownCaseAlternativeError+unknownCaseAlternativeError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError+unknownCaseAlternativeError location typeName name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownCaseAlternativeError"),+      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)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the location field of hydra.error.core.UnknownCaseAlternativeError+unknownCaseAlternativeErrorLocation :: Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError -> Typed.TypedTerm Paths.SubtermPath+unknownCaseAlternativeErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownCaseAlternativeError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.error.core.UnknownCaseAlternativeError+unknownCaseAlternativeErrorName :: Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError -> Typed.TypedTerm Core.Name+unknownCaseAlternativeErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownCaseAlternativeError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeName field of hydra.error.core.UnknownCaseAlternativeError+unknownCaseAlternativeErrorTypeName :: Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError -> Typed.TypedTerm Core.Name+unknownCaseAlternativeErrorTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownCaseAlternativeError"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.error.core.UnknownCaseAlternativeError+unknownCaseAlternativeErrorUnknownCaseAlternativeError :: Typed.TypedName ErrorCore.UnknownCaseAlternativeError+unknownCaseAlternativeErrorUnknownCaseAlternativeError =+    Typed.TypedName (Core.Name "hydra.error.core.UnknownCaseAlternativeError")++-- | DSL updater for the location field of hydra.error.core.UnknownCaseAlternativeError+unknownCaseAlternativeErrorWithLocation :: Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError+unknownCaseAlternativeErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownCaseAlternativeError"),+      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.UnknownCaseAlternativeError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            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.core.UnknownCaseAlternativeError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.error.core.UnknownCaseAlternativeError+unknownCaseAlternativeErrorWithName :: Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError+unknownCaseAlternativeErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownCaseAlternativeError"),+      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.UnknownCaseAlternativeError"),+              Core.projectionFieldName = (Core.Name "location")})),+            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.core.UnknownCaseAlternativeError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the typeName field of hydra.error.core.UnknownCaseAlternativeError+unknownCaseAlternativeErrorWithTypeName :: Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UnknownCaseAlternativeError+unknownCaseAlternativeErrorWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownCaseAlternativeError"),+      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.UnknownCaseAlternativeError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          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.UnknownCaseAlternativeError"),+              Core.projectionFieldName = (Core.Name "name")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL constructor for hydra.error.core.UnknownPrimitiveNameError

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -51,6 +52,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -49,6 +50,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Strip as DslStrip import qualified Hydra.Dsl.System as DslSystem@@ -51,9 +52,10 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational-import qualified Hydra.Show.Core as ShowCore import qualified Hydra.Strip as Strip import qualified Hydra.Substitution as Substitution import qualified Hydra.System as System

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -49,6 +50,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Strip as DslStrip import qualified Hydra.Dsl.System as DslSystem@@ -51,9 +52,10 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational-import qualified Hydra.Show.Core as ShowCore import qualified Hydra.Strip as Strip import qualified Hydra.Substitution as Substitution import qualified Hydra.System as System

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -50,6 +51,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Serialization as DslSerialization import qualified Hydra.Dsl.System as DslSystem@@ -50,6 +51,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Serialization as Serialization import qualified Hydra.System as System

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -52,6 +53,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -52,6 +53,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Scoping as DslScoping import qualified Hydra.Dsl.Strip as DslStrip@@ -50,11 +51,12 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -62,11 +64,25 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL reference to hydra.lib.chars.isAlpha+isAlpha :: Typed.TypedTerm Int -> Typed.TypedTerm Bool+isAlpha arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.chars.isAlpha")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))+ -- | DSL reference to hydra.lib.chars.isAlphaNum isAlphaNum :: Typed.TypedTerm Int -> Typed.TypedTerm Bool isAlphaNum arg0 =     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.chars.isAlphaNum")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.lib.chars.isDigit+isDigit :: Typed.TypedTerm Int -> Typed.TypedTerm Bool+isDigit arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.chars.isDigit")),       Core.applicationArgument = (Typed.unTypedTerm arg0)}))  -- | DSL reference to hydra.lib.chars.isLower

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -63,6 +65,15 @@ import qualified Data.Scientific as Sci import qualified Data.Set as S +-- | DSL reference to hydra.lib.eithers.apply+apply :: Typed.TypedTerm (Either x (y -> z)) -> Typed.TypedTerm (Either x y) -> Typed.TypedTerm (Either x z)+apply arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.apply")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.eithers.bimap bimap :: Typed.TypedTerm (x -> z) -> Typed.TypedTerm (y -> w) -> Typed.TypedTerm (Either x y) -> Typed.TypedTerm (Either z w) bimap arg0 arg1 arg2 =@@ -83,6 +94,17 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.eithers.compose+compose :: Typed.TypedTerm (x -> Either w y) -> Typed.TypedTerm (y -> Either w z) -> Typed.TypedTerm x -> Typed.TypedTerm (Either w z)+compose arg0 arg1 arg2 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.compose")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))+ -- | DSL reference to hydra.lib.eithers.either either :: Typed.TypedTerm (x -> z) -> Typed.TypedTerm (y -> z) -> Typed.TypedTerm (Either x y) -> Typed.TypedTerm z either arg0 arg1 arg2 =@@ -94,6 +116,17 @@         Core.applicationArgument = (Typed.unTypedTerm arg1)})),       Core.applicationArgument = (Typed.unTypedTerm arg2)})) +-- | DSL reference to hydra.lib.eithers.foldList+foldList :: Typed.TypedTerm (x -> y -> Either z x) -> Typed.TypedTerm x -> Typed.TypedTerm [y] -> Typed.TypedTerm (Either z x)+foldList arg0 arg1 arg2 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.foldList")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))+ -- | DSL reference to hydra.lib.eithers.foldl foldl :: Typed.TypedTerm (x -> y -> Either z x) -> Typed.TypedTerm x -> Typed.TypedTerm [y] -> Typed.TypedTerm (Either z x) foldl arg0 arg1 arg2 =@@ -180,11 +213,25 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.eithers.partition+partition :: Typed.TypedTerm [Either x y] -> Typed.TypedTerm ([x], [y])+partition arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.partition")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))+ -- | DSL reference to hydra.lib.eithers.partitionEithers partitionEithers :: Typed.TypedTerm [Either x y] -> Typed.TypedTerm ([x], [y]) partitionEithers arg0 =     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.partitionEithers")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.lib.eithers.pure+pure :: Typed.TypedTerm y -> Typed.TypedTerm (Either x y)+pure arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.pure")),       Core.applicationArgument = (Typed.unTypedTerm arg0)}))  -- | DSL reference to hydra.lib.eithers.rights

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -138,5 +140,14 @@     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermApplication (Core.Application {         Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.min")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.equality.notEqual+notEqual :: Typed.TypedTerm x -> Typed.TypedTerm x -> Typed.TypedTerm Bool+notEqual arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.notEqual")),         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)}))

@@ -0,0 +1,103 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.lib.functions++module Hydra.Dsl.Lib.Functions where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Docs as Docs+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Docs as DslDocs+import qualified Hydra.Dsl.Error.Checking as ErrorChecking+import qualified Hydra.Dsl.Error.Core as DslErrorCore+import qualified Hydra.Dsl.Error.File as DslErrorFile+import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging+import qualified Hydra.Dsl.Error.System as DslErrorSystem+import qualified Hydra.Dsl.Errors as DslErrors+import qualified Hydra.Dsl.File as DslFile+import qualified Hydra.Dsl.Graph as DslGraph+import qualified Hydra.Dsl.Json.Model as JsonModel+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Dsl.Parsing as DslParsing+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex+import qualified Hydra.Dsl.Relational as DslRelational+import qualified Hydra.Dsl.System as DslSystem+import qualified Hydra.Dsl.Tabular as DslTabular+import qualified Hydra.Dsl.Testing as DslTesting+import qualified Hydra.Dsl.Time as DslTime+import qualified Hydra.Dsl.Topology as DslTopology+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Dsl.Validation as DslValidation+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.File as ErrorFile+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Error.System as ErrorSystem+import qualified Hydra.Errors as Errors+import qualified Hydra.File as File+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.Regex as Regex+import qualified Hydra.Relational as Relational+import qualified Hydra.System as System+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Time as Time+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++-- | DSL reference to hydra.lib.functions.compose+compose :: Typed.TypedTerm (t2 -> t3) -> Typed.TypedTerm (t1 -> t2) -> Typed.TypedTerm t1 -> Typed.TypedTerm t3+compose arg0 arg1 arg2 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.functions.compose")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.lib.functions.const+const :: Typed.TypedTerm t1 -> Typed.TypedTerm t2 -> Typed.TypedTerm t1+const arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.functions.const")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.functions.flip+flip :: Typed.TypedTerm (t1 -> t2 -> t3) -> Typed.TypedTerm t2 -> Typed.TypedTerm t1 -> Typed.TypedTerm t3+flip arg0 arg1 arg2 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.functions.flip")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.lib.functions.identity+identity :: Typed.TypedTerm t1 -> Typed.TypedTerm t1+identity arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.functions.identity")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -61,6 +63,7 @@ import qualified Hydra.Variants as Variants import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci+import qualified Data.Set as S  -- | DSL reference to hydra.lib.lists.apply apply :: Typed.TypedTerm [x -> y] -> Typed.TypedTerm [x] -> Typed.TypedTerm [y]@@ -71,6 +74,15 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.lists.at+at :: Typed.TypedTerm Int -> Typed.TypedTerm [x] -> Typed.TypedTerm (Maybe x)+at arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.at")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.lists.bind bind :: Typed.TypedTerm [x] -> Typed.TypedTerm (x -> [y]) -> Typed.TypedTerm [y] bind arg0 arg1 =@@ -80,6 +92,17 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.lists.compose+compose :: Typed.TypedTerm (x -> [y]) -> Typed.TypedTerm (y -> [z]) -> Typed.TypedTerm x -> Typed.TypedTerm [z]+compose arg0 arg1 arg2 =+    Typed.TypedTerm (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.compose")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))+ -- | DSL reference to hydra.lib.lists.concat concat :: Typed.TypedTerm [[x]] -> Typed.TypedTerm [x] concat arg0 =@@ -105,6 +128,13 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.lists.distinct+distinct :: Typed.TypedTerm [x] -> Typed.TypedTerm [x]+distinct arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.distinct")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))+ -- | DSL reference to hydra.lib.lists.drop drop :: Typed.TypedTerm Int -> Typed.TypedTerm [x] -> Typed.TypedTerm [x] drop arg0 arg1 =@@ -150,6 +180,17 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.lists.foldList+foldList :: Typed.TypedTerm (x -> y -> [x]) -> Typed.TypedTerm x -> Typed.TypedTerm [y] -> Typed.TypedTerm [x]+foldList arg0 arg1 arg2 =+    Typed.TypedTerm (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.foldList")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))+ -- | DSL reference to hydra.lib.lists.foldl foldl :: Typed.TypedTerm (y -> x -> y) -> Typed.TypedTerm y -> Typed.TypedTerm [x] -> Typed.TypedTerm y foldl arg0 arg1 arg2 =@@ -179,6 +220,20 @@       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.group")),       Core.applicationArgument = (Typed.unTypedTerm arg0)})) +-- | DSL reference to hydra.lib.lists.head+head :: Typed.TypedTerm [x] -> Typed.TypedTerm (Maybe x)+head arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.head")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.lib.lists.init+init :: Typed.TypedTerm [x] -> Typed.TypedTerm (Maybe [x])+init arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.init")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))+ -- | DSL reference to hydra.lib.lists.intercalate intercalate :: Typed.TypedTerm [x] -> Typed.TypedTerm [[x]] -> Typed.TypedTerm [x] intercalate arg0 arg1 =@@ -197,6 +252,22 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.lists.join+join :: Typed.TypedTerm [x] -> Typed.TypedTerm [[x]] -> Typed.TypedTerm [x]+join arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.join")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.lists.last+last :: Typed.TypedTerm [x] -> Typed.TypedTerm (Maybe x)+last arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.last")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))+ -- | DSL reference to hydra.lib.lists.length length :: Typed.TypedTerm [x] -> Typed.TypedTerm Int length arg0 =@@ -213,6 +284,33 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.lists.mapList+mapList :: Typed.TypedTerm (x -> [y]) -> Typed.TypedTerm [x] -> Typed.TypedTerm [[y]]+mapList arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.mapList")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.lists.mapOptional+mapOptional :: Typed.TypedTerm (x -> [y]) -> Typed.TypedTerm (Maybe x) -> Typed.TypedTerm [Maybe y]+mapOptional arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.mapOptional")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.lists.mapSet+mapSet :: (Ord x, Ord y) => (Typed.TypedTerm (x -> [y]) -> Typed.TypedTerm (S.Set x) -> Typed.TypedTerm [S.Set y])+mapSet arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.mapSet")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.lists.maybeAt maybeAt :: Typed.TypedTerm Int -> Typed.TypedTerm [x] -> Typed.TypedTerm (Maybe x) maybeAt arg0 arg1 =@@ -250,6 +348,15 @@       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.maybeTail")),       Core.applicationArgument = (Typed.unTypedTerm arg0)})) +-- | DSL reference to hydra.lib.lists.member+member :: Typed.TypedTerm x -> Typed.TypedTerm [x] -> Typed.TypedTerm Bool+member arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.member")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.lists.nub nub :: Typed.TypedTerm [x] -> Typed.TypedTerm [x] nub arg0 =@@ -310,6 +417,15 @@       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.sort")),       Core.applicationArgument = (Typed.unTypedTerm arg0)})) +-- | DSL reference to hydra.lib.lists.sortBy+sortBy :: Typed.TypedTerm (x -> y) -> Typed.TypedTerm [x] -> Typed.TypedTerm [x]+sortBy arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.sortBy")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.lists.sortOn sortOn :: Typed.TypedTerm (x -> y) -> Typed.TypedTerm [x] -> Typed.TypedTerm [x] sortOn arg0 arg1 =@@ -328,12 +444,28 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.lists.tail+tail :: Typed.TypedTerm [x] -> Typed.TypedTerm (Maybe [x])+tail arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.tail")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))+ -- | DSL reference to hydra.lib.lists.take take :: Typed.TypedTerm Int -> Typed.TypedTerm [x] -> Typed.TypedTerm [x] take arg0 arg1 =     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermApplication (Core.Application {         Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.take")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.lists.takeWhile+takeWhile :: Typed.TypedTerm (x -> Bool) -> Typed.TypedTerm [x] -> Typed.TypedTerm [x]+takeWhile arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.takeWhile")),         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) 

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -94,6 +96,15 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.maps.difference+difference :: Ord k => (Typed.TypedTerm (M.Map k v) -> Typed.TypedTerm (M.Map k v) -> Typed.TypedTerm (M.Map k v))+difference arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.difference")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.maps.elems elems :: Ord k => (Typed.TypedTerm (M.Map k v) -> Typed.TypedTerm [v]) elems arg0 =@@ -152,6 +163,15 @@         Core.applicationArgument = (Typed.unTypedTerm arg1)})),       Core.applicationArgument = (Typed.unTypedTerm arg2)})) +-- | DSL reference to hydra.lib.maps.intersection+intersection :: Ord k => (Typed.TypedTerm (M.Map k v) -> Typed.TypedTerm (M.Map k v) -> Typed.TypedTerm (M.Map k v))+intersection arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.intersection")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.maps.keys keys :: Ord k => (Typed.TypedTerm (M.Map k v) -> Typed.TypedTerm [k]) keys arg0 =@@ -233,3 +253,10 @@         Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.union")),         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.maps.unions+unions :: Ord k => (Typed.TypedTerm [M.Map k v] -> Typed.TypedTerm (M.Map k v))+unions arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.unions")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -61,6 +63,7 @@ import qualified Hydra.Variants as Variants import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci+import qualified Data.Set as S  -- | DSL reference to hydra.lib.optionals.apply apply :: Typed.TypedTerm (Maybe (x -> y)) -> Typed.TypedTerm (Maybe x) -> Typed.TypedTerm (Maybe y)@@ -109,6 +112,17 @@         Core.applicationArgument = (Typed.unTypedTerm arg1)})),       Core.applicationArgument = (Typed.unTypedTerm arg2)})) +-- | DSL reference to hydra.lib.optionals.foldList+foldList :: Typed.TypedTerm (x -> y -> Maybe x) -> Typed.TypedTerm x -> Typed.TypedTerm [y] -> Typed.TypedTerm (Maybe x)+foldList arg0 arg1 arg2 =+    Typed.TypedTerm (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.foldList")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))+ -- | DSL reference to hydra.lib.optionals.fromOptional fromOptional :: Typed.TypedTerm x -> Typed.TypedTerm (Maybe x) -> Typed.TypedTerm x fromOptional arg0 arg1 =@@ -118,6 +132,13 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.optionals.givens+givens :: Typed.TypedTerm [Maybe x] -> Typed.TypedTerm [x]+givens arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.givens")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))+ -- | DSL reference to hydra.lib.optionals.isGiven isGiven :: Typed.TypedTerm (Maybe x) -> Typed.TypedTerm Bool isGiven arg0 =@@ -141,6 +162,15 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.optionals.mapList+mapList :: Typed.TypedTerm (x -> Maybe y) -> Typed.TypedTerm [x] -> Typed.TypedTerm (Maybe [y])+mapList arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.mapList")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.optionals.mapOptional mapOptional :: Typed.TypedTerm (x -> Maybe y) -> Typed.TypedTerm [x] -> Typed.TypedTerm [y] mapOptional arg0 arg1 =@@ -150,6 +180,15 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.optionals.mapSet+mapSet :: (Ord x, Ord y) => (Typed.TypedTerm (x -> Maybe y) -> Typed.TypedTerm (S.Set x) -> Typed.TypedTerm (Maybe (S.Set y)))+mapSet arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.mapSet")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.optionals.pure pure :: Typed.TypedTerm x -> Typed.TypedTerm (Maybe x) pure arg0 =@@ -163,3 +202,12 @@     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.toList")),       Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.lib.optionals.withDefault+withDefault :: Typed.TypedTerm x -> Typed.TypedTerm (Maybe x) -> Typed.TypedTerm x+withDefault arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.withDefault")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -84,6 +86,15 @@ -- | DSL reference to hydra.lib.sets.empty empty :: Ord x => (Typed.TypedTerm (S.Set x)) empty = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.lib.sets.empty"))++-- | DSL reference to hydra.lib.sets.filter+filter :: Ord x => (Typed.TypedTerm (x -> Bool) -> Typed.TypedTerm (S.Set x) -> Typed.TypedTerm (S.Set x))+filter arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.filter")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))  -- | DSL reference to hydra.lib.sets.fromList fromList :: Ord x => (Typed.TypedTerm [x] -> Typed.TypedTerm (S.Set x))

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -78,6 +80,31 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.lib.strings.charAt+charAt :: Typed.TypedTerm Int -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Int)+charAt arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.charAt")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.strings.concat+concat :: Typed.TypedTerm [String] -> Typed.TypedTerm String+concat arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.concat")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.lib.strings.concat2+concat2 :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String+concat2 arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.concat2")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))+ -- | DSL reference to hydra.lib.strings.fromList fromList :: Typed.TypedTerm [Int] -> Typed.TypedTerm String fromList arg0 =@@ -91,6 +118,15 @@     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermApplication (Core.Application {         Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.intercalate")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lib.strings.join+join :: Typed.TypedTerm String -> Typed.TypedTerm [String] -> Typed.TypedTerm String+join arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.join")),         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) 

@@ -30,6 +30,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -55,6 +56,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -31,6 +31,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Rewriting as DslRewriting import qualified Hydra.Dsl.Scoping as DslScoping@@ -60,6 +61,7 @@ import qualified Hydra.Predicates as Predicates import qualified Hydra.Query as Query import qualified Hydra.Reflect as Reflect+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Scoping as Scoping

@@ -0,0 +1,129 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.print.docs++module Hydra.Dsl.Print.Docs where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Docs as Docs+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Docs as DslDocs+import qualified Hydra.Dsl.Error.Checking as ErrorChecking+import qualified Hydra.Dsl.Error.Core as DslErrorCore+import qualified Hydra.Dsl.Error.File as DslErrorFile+import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging+import qualified Hydra.Dsl.Error.System as DslErrorSystem+import qualified Hydra.Dsl.Errors as DslErrors+import qualified Hydra.Dsl.File as DslFile+import qualified Hydra.Dsl.Graph as DslGraph+import qualified Hydra.Dsl.Json.Model as JsonModel+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Dsl.Parsing as DslParsing+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex+import qualified Hydra.Dsl.Relational as DslRelational+import qualified Hydra.Dsl.System as DslSystem+import qualified Hydra.Dsl.Tabular as DslTabular+import qualified Hydra.Dsl.Testing as DslTesting+import qualified Hydra.Dsl.Time as DslTime+import qualified Hydra.Dsl.Topology as DslTopology+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Dsl.Validation as DslValidation+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.File as ErrorFile+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Error.System as ErrorSystem+import qualified Hydra.Errors as Errors+import qualified Hydra.File as File+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parse.Docs as ParseDocs+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Docs as PrintDocs+import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex+import qualified Hydra.Relational as Relational+import qualified Hydra.System as System+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Time as Time+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++-- | DSL reference to hydra.print.docs.definitionReference+definitionReference :: Typed.TypedTerm Packaging.DefinitionReference -> Typed.TypedTerm String+definitionReference arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.print.docs.definitionReference")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.print.docs.docSegment+docSegment :: Typed.TypedTerm Docs.DocSegment -> Typed.TypedTerm String+docSegment arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.print.docs.docSegment")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.print.docs.docSegmentWith+docSegmentWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm Docs.DocSegment -> Typed.TypedTerm String+docSegmentWith arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.print.docs.docSegmentWith")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.print.docs.docSegments+docSegments :: Typed.TypedTerm [Docs.DocSegment] -> Typed.TypedTerm String+docSegments arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.print.docs.docSegments")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.print.docs.docSegmentsWith+docSegmentsWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm [Docs.DocSegment] -> Typed.TypedTerm String+docSegmentsWith arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.print.docs.docSegmentsWith")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.print.docs.entityReference+entityReference :: Typed.TypedTerm Packaging.EntityReference -> Typed.TypedTerm String+entityReference arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.print.docs.entityReference")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.print.docs.renderDocString+renderDocString :: Typed.TypedTerm String -> Typed.TypedTerm String+renderDocString arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.print.docs.renderDocString")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.print.docs.renderDocStringWith+renderDocStringWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm String -> Typed.TypedTerm String+renderDocStringWith arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.print.docs.renderDocStringWith")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))

@@ -32,6 +32,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Resolution as DslResolution import qualified Hydra.Dsl.Rewriting as DslRewriting@@ -63,14 +64,15 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query import qualified Hydra.Reduction as Reduction+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -51,6 +52,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query import qualified Hydra.Refs as Refs+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -0,0 +1,436 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.regex++module Hydra.Dsl.Regex where++import qualified Hydra.Core as Core+import qualified Hydra.Decode.Regex as DecodeRegex+import qualified Hydra.Encode.Regex as EncodeRegex+import qualified Hydra.Regex as Regex+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 anchorEnd variant of hydra.regex.Atom+atomAnchorEnd :: Typed.TypedTerm Regex.Atom+atomAnchorEnd =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "anchorEnd"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the anchorStart variant of hydra.regex.Atom+atomAnchorStart :: Typed.TypedTerm Regex.Atom+atomAnchorStart =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "anchorStart"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the any variant of hydra.regex.Atom+atomAny :: Typed.TypedTerm Regex.Atom+atomAny =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "any"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL name token for hydra.regex.Atom+atomAtom :: Typed.TypedName Regex.Atom+atomAtom = Typed.TypedName (Core.Name "hydra.regex.Atom")++-- | DSL injection for the class variant of hydra.regex.Atom+atomClass :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm Regex.Atom+atomClass x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "class"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the group variant of hydra.regex.Atom+atomGroup :: Typed.TypedTerm Regex.Alternation -> Typed.TypedTerm Regex.Atom+atomGroup x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "group"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the literal variant of hydra.regex.Atom+atomLiteral :: Typed.TypedTerm Int -> Typed.TypedTerm Regex.Atom+atomLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.regex.CharacterClass+characterClass :: Typed.TypedTerm Bool -> Typed.TypedTerm [Regex.ClassItem] -> Typed.TypedTerm Regex.CharacterClass+characterClass negated items =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.CharacterClass"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "negated"),+          Core.fieldTerm = (Typed.unTypedTerm negated)},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Typed.unTypedTerm items)}]}))++-- | DSL name token for hydra.regex.CharacterClass+characterClassCharacterClass :: Typed.TypedName Regex.CharacterClass+characterClassCharacterClass = Typed.TypedName (Core.Name "hydra.regex.CharacterClass")++-- | DSL accessor for the items field of hydra.regex.CharacterClass+characterClassItems :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm [Regex.ClassItem]+characterClassItems x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.regex.CharacterClass"),+        Core.projectionFieldName = (Core.Name "items")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the negated field of hydra.regex.CharacterClass+characterClassNegated :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm Bool+characterClassNegated x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.regex.CharacterClass"),+        Core.projectionFieldName = (Core.Name "negated")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the items field of hydra.regex.CharacterClass+characterClassWithItems :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm [Regex.ClassItem] -> Typed.TypedTerm Regex.CharacterClass+characterClassWithItems original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.CharacterClass"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "negated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.regex.CharacterClass"),+              Core.projectionFieldName = (Core.Name "negated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the negated field of hydra.regex.CharacterClass+characterClassWithNegated :: Typed.TypedTerm Regex.CharacterClass -> Typed.TypedTerm Bool -> Typed.TypedTerm Regex.CharacterClass+characterClassWithNegated original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.CharacterClass"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "negated"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.regex.CharacterClass"),+              Core.projectionFieldName = (Core.Name "items")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.regex.CharacterRange+characterRange :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.CharacterRange+characterRange from to =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.CharacterRange"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "from"),+          Core.fieldTerm = (Typed.unTypedTerm from)},+        Core.Field {+          Core.fieldName = (Core.Name "to"),+          Core.fieldTerm = (Typed.unTypedTerm to)}]}))++-- | DSL name token for hydra.regex.CharacterRange+characterRangeCharacterRange :: Typed.TypedName Regex.CharacterRange+characterRangeCharacterRange = Typed.TypedName (Core.Name "hydra.regex.CharacterRange")++-- | DSL accessor for the from field of hydra.regex.CharacterRange+characterRangeFrom :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Int+characterRangeFrom x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.regex.CharacterRange"),+        Core.projectionFieldName = (Core.Name "from")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the to field of hydra.regex.CharacterRange+characterRangeTo :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Int+characterRangeTo x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.regex.CharacterRange"),+        Core.projectionFieldName = (Core.Name "to")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the from field of hydra.regex.CharacterRange+characterRangeWithFrom :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.CharacterRange+characterRangeWithFrom original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.CharacterRange"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "from"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "to"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.regex.CharacterRange"),+              Core.projectionFieldName = (Core.Name "to")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the to field of hydra.regex.CharacterRange+characterRangeWithTo :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.CharacterRange+characterRangeWithTo original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.CharacterRange"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "from"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.regex.CharacterRange"),+              Core.projectionFieldName = (Core.Name "from")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "to"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the character variant of hydra.regex.ClassItem+classItemCharacter :: Typed.TypedTerm Int -> Typed.TypedTerm Regex.ClassItem+classItemCharacter x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.ClassItem"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "character"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.regex.ClassItem+classItemClassItem :: Typed.TypedName Regex.ClassItem+classItemClassItem = Typed.TypedName (Core.Name "hydra.regex.ClassItem")++-- | DSL injection for the range variant of hydra.regex.ClassItem+classItemRange :: Typed.TypedTerm Regex.CharacterRange -> Typed.TypedTerm Regex.ClassItem+classItemRange x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.ClassItem"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "range"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.regex.Quantified+quantified :: Typed.TypedTerm Regex.Atom -> Typed.TypedTerm Regex.Quantifier -> Typed.TypedTerm Regex.Quantified+quantified atom quantifier =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.Quantified"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "atom"),+          Core.fieldTerm = (Typed.unTypedTerm atom)},+        Core.Field {+          Core.fieldName = (Core.Name "quantifier"),+          Core.fieldTerm = (Typed.unTypedTerm quantifier)}]}))++-- | DSL accessor for the atom field of hydra.regex.Quantified+quantifiedAtom :: Typed.TypedTerm Regex.Quantified -> Typed.TypedTerm Regex.Atom+quantifiedAtom x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.regex.Quantified"),+        Core.projectionFieldName = (Core.Name "atom")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.regex.Quantified+quantifiedQuantified :: Typed.TypedName Regex.Quantified+quantifiedQuantified = Typed.TypedName (Core.Name "hydra.regex.Quantified")++-- | DSL accessor for the quantifier field of hydra.regex.Quantified+quantifiedQuantifier :: Typed.TypedTerm Regex.Quantified -> Typed.TypedTerm Regex.Quantifier+quantifiedQuantifier x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.regex.Quantified"),+        Core.projectionFieldName = (Core.Name "quantifier")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the atom field of hydra.regex.Quantified+quantifiedWithAtom :: Typed.TypedTerm Regex.Quantified -> Typed.TypedTerm Regex.Atom -> Typed.TypedTerm Regex.Quantified+quantifiedWithAtom original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.Quantified"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "atom"),+          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.regex.Quantified"),+              Core.projectionFieldName = (Core.Name "quantifier")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the quantifier field of hydra.regex.Quantified+quantifiedWithQuantifier :: Typed.TypedTerm Regex.Quantified -> Typed.TypedTerm Regex.Quantifier -> Typed.TypedTerm Regex.Quantified+quantifiedWithQuantifier original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.Quantified"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "atom"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.regex.Quantified"),+              Core.projectionFieldName = (Core.Name "atom")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "quantifier"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the atLeast variant of hydra.regex.Quantifier+quantifierAtLeast :: Typed.TypedTerm Int -> Typed.TypedTerm Regex.Quantifier+quantifierAtLeast x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "atLeast"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the exactly variant of hydra.regex.Quantifier+quantifierExactly :: Typed.TypedTerm Int -> Typed.TypedTerm Regex.Quantifier+quantifierExactly x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "exactly"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the one variant of hydra.regex.Quantifier+quantifierOne :: Typed.TypedTerm Regex.Quantifier+quantifierOne =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "one"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the oneOrMore variant of hydra.regex.Quantifier+quantifierOneOrMore :: Typed.TypedTerm Regex.Quantifier+quantifierOneOrMore =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "oneOrMore"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL name token for hydra.regex.Quantifier+quantifierQuantifier :: Typed.TypedName Regex.Quantifier+quantifierQuantifier = Typed.TypedName (Core.Name "hydra.regex.Quantifier")++-- | DSL injection for the range variant of hydra.regex.Quantifier+quantifierRange :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Regex.Quantifier+quantifierRange x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "range"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.regex.QuantifierRange+quantifierRange2 :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.QuantifierRange+quantifierRange2 min max =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.QuantifierRange"),+      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.regex.QuantifierRange+quantifierRangeMax :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Int+quantifierRangeMax x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.regex.QuantifierRange"),+        Core.projectionFieldName = (Core.Name "max")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the min field of hydra.regex.QuantifierRange+quantifierRangeMin :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Int+quantifierRangeMin x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.regex.QuantifierRange"),+        Core.projectionFieldName = (Core.Name "min")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.regex.QuantifierRange+quantifierRangeQuantifierRange :: Typed.TypedName Regex.QuantifierRange+quantifierRangeQuantifierRange = Typed.TypedName (Core.Name "hydra.regex.QuantifierRange")++-- | DSL updater for the max field of hydra.regex.QuantifierRange+quantifierRangeWithMax :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.QuantifierRange+quantifierRangeWithMax original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.QuantifierRange"),+      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.regex.QuantifierRange"),+              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.regex.QuantifierRange+quantifierRangeWithMin :: Typed.TypedTerm Regex.QuantifierRange -> Typed.TypedTerm Int -> Typed.TypedTerm Regex.QuantifierRange+quantifierRangeWithMin original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.QuantifierRange"),+      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.regex.QuantifierRange"),+              Core.projectionFieldName = (Core.Name "max")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the zeroOrMore variant of hydra.regex.Quantifier+quantifierZeroOrMore :: Typed.TypedTerm Regex.Quantifier+quantifierZeroOrMore =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "zeroOrMore"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the zeroOrOne variant of hydra.regex.Quantifier+quantifierZeroOrOne :: Typed.TypedTerm Regex.Quantifier+quantifierZeroOrOne =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "zeroOrOne"),+        Core.fieldTerm = Core.TermUnit}}))

@@ -27,6 +27,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Scoping as DslScoping import qualified Hydra.Dsl.Strip as DslStrip@@ -54,11 +55,12 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Resolution as Resolution 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.System as System

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Scoping as DslScoping import qualified Hydra.Dsl.System as DslSystem@@ -49,6 +50,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Scoping as Scoping

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Scoping as Scoping import qualified Hydra.System as System

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -48,6 +49,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Serialization as Serialization import qualified Hydra.System as System

@@ -1,127 +0,0 @@--- Note: this is an automatically generated file. Do not edit.---- | DSL functions for hydra.show.docs--module Hydra.Dsl.Show.Docs where--import qualified Hydra.Ast as Ast-import qualified Hydra.Coders as Coders-import qualified Hydra.Core as Core-import qualified Hydra.Docs as Docs-import qualified Hydra.Dsl.Ast as DslAst-import qualified Hydra.Dsl.Coders as DslCoders-import qualified Hydra.Dsl.Core as DslCore-import qualified Hydra.Dsl.Docs as DslDocs-import qualified Hydra.Dsl.Error.Checking as ErrorChecking-import qualified Hydra.Dsl.Error.Core as DslErrorCore-import qualified Hydra.Dsl.Error.File as DslErrorFile-import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging-import qualified Hydra.Dsl.Error.System as DslErrorSystem-import qualified Hydra.Dsl.Errors as DslErrors-import qualified Hydra.Dsl.File as DslFile-import qualified Hydra.Dsl.Graph as DslGraph-import qualified Hydra.Dsl.Json.Model as JsonModel-import qualified Hydra.Dsl.Packaging as DslPackaging-import qualified Hydra.Dsl.Parsing as DslParsing-import qualified Hydra.Dsl.Paths as DslPaths-import qualified Hydra.Dsl.Query as DslQuery-import qualified Hydra.Dsl.Relational as DslRelational-import qualified Hydra.Dsl.System as DslSystem-import qualified Hydra.Dsl.Tabular as DslTabular-import qualified Hydra.Dsl.Testing as DslTesting-import qualified Hydra.Dsl.Time as DslTime-import qualified Hydra.Dsl.Topology as DslTopology-import qualified Hydra.Dsl.Typing as DslTyping-import qualified Hydra.Dsl.Util as DslUtil-import qualified Hydra.Dsl.Validation as DslValidation-import qualified Hydra.Dsl.Variants as DslVariants-import qualified Hydra.Error.Checking as Checking-import qualified Hydra.Error.Core as ErrorCore-import qualified Hydra.Error.File as ErrorFile-import qualified Hydra.Error.Packaging as ErrorPackaging-import qualified Hydra.Error.System as ErrorSystem-import qualified Hydra.Errors as Errors-import qualified Hydra.File as File-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.Read.Docs as ReadDocs-import qualified Hydra.Relational as Relational-import qualified Hydra.Show.Docs as ShowDocs-import qualified Hydra.System as System-import qualified Hydra.Tabular as Tabular-import qualified Hydra.Testing as Testing-import qualified Hydra.Time as Time-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---- | DSL reference to hydra.show.docs.definitionReference-definitionReference :: Typed.TypedTerm Packaging.DefinitionReference -> Typed.TypedTerm String-definitionReference arg0 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.definitionReference")),-      Core.applicationArgument = (Typed.unTypedTerm arg0)}))---- | DSL reference to hydra.show.docs.docSegment-docSegment :: Typed.TypedTerm Docs.DocSegment -> Typed.TypedTerm String-docSegment arg0 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.docSegment")),-      Core.applicationArgument = (Typed.unTypedTerm arg0)}))---- | DSL reference to hydra.show.docs.docSegmentWith-docSegmentWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm Docs.DocSegment -> Typed.TypedTerm String-docSegmentWith arg0 arg1 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermApplication (Core.Application {-        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.docSegmentWith")),-        Core.applicationArgument = (Typed.unTypedTerm arg0)})),-      Core.applicationArgument = (Typed.unTypedTerm arg1)}))---- | DSL reference to hydra.show.docs.docSegments-docSegments :: Typed.TypedTerm [Docs.DocSegment] -> Typed.TypedTerm String-docSegments arg0 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.docSegments")),-      Core.applicationArgument = (Typed.unTypedTerm arg0)}))---- | DSL reference to hydra.show.docs.docSegmentsWith-docSegmentsWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm [Docs.DocSegment] -> Typed.TypedTerm String-docSegmentsWith arg0 arg1 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermApplication (Core.Application {-        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.docSegmentsWith")),-        Core.applicationArgument = (Typed.unTypedTerm arg0)})),-      Core.applicationArgument = (Typed.unTypedTerm arg1)}))---- | DSL reference to hydra.show.docs.entityReference-entityReference :: Typed.TypedTerm Packaging.EntityReference -> Typed.TypedTerm String-entityReference arg0 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.entityReference")),-      Core.applicationArgument = (Typed.unTypedTerm arg0)}))---- | DSL reference to hydra.show.docs.renderDocString-renderDocString :: Typed.TypedTerm String -> Typed.TypedTerm String-renderDocString arg0 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.renderDocString")),-      Core.applicationArgument = (Typed.unTypedTerm arg0)}))---- | DSL reference to hydra.show.docs.renderDocStringWith-renderDocStringWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm String -> Typed.TypedTerm String-renderDocStringWith arg0 arg1 =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermApplication (Core.Application {-        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.renderDocStringWith")),-        Core.applicationArgument = (Typed.unTypedTerm arg0)})),-      Core.applicationArgument = (Typed.unTypedTerm arg1)}))

@@ -27,6 +27,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -50,6 +51,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Sorting as Sorting import qualified Hydra.System as System

@@ -25,6 +25,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Rewriting as DslRewriting import qualified Hydra.Dsl.System as DslSystem@@ -49,6 +50,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Strip as Strip

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Sorting as DslSorting import qualified Hydra.Dsl.System as DslSystem@@ -51,6 +52,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Sorting as Sorting import qualified Hydra.System as System

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.System as DslSystem import qualified Hydra.Dsl.Tabular as DslTabular@@ -50,9 +51,10 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational-import qualified Hydra.Show.Errors as ShowErrors import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Test.Utils as Utils

@@ -26,6 +26,7 @@ import qualified Hydra.Dsl.Parsing as DslParsing import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Regex as DslRegex import qualified Hydra.Dsl.Relational as DslRelational import qualified Hydra.Dsl.Rewriting as DslRewriting import qualified Hydra.Dsl.System as DslSystem@@ -51,6 +52,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.System as System

@@ -37,6 +37,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Scoping as Scoping import qualified Hydra.Strip as Strip

@@ -9,6 +9,7 @@ import qualified Hydra.Encode.Paths as Paths import qualified Hydra.Encode.Variants as Variants import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci @@ -253,6 +254,11 @@         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"),           Core.fieldTerm = (invalidTypeLambdaParameterNameError v0)}})+      ErrorCore.InvalidTermErrorMissingCaseBranches v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "missingCaseBranches"),+          Core.fieldTerm = (missingCaseBranchesError v0)}})       ErrorCore.InvalidTermErrorNestedTermAnnotation v0 -> Core.TermInject (Core.Injection {         Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),         Core.injectionField = Core.Field {@@ -298,6 +304,11 @@         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"),           Core.fieldTerm = (undefinedTypeVariableInTypeApplicationError v0)}})+      ErrorCore.InvalidTermErrorUnknownCaseAlternative v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unknownCaseAlternative"),+          Core.fieldTerm = (unknownCaseAlternativeError v0)}})       ErrorCore.InvalidTermErrorUnknownPrimitiveName v0 -> Core.TermInject (Core.Injection {         Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),         Core.injectionField = Core.Field {@@ -428,6 +439,22 @@           Core.fieldName = (Core.Name "actualType"),           Core.fieldTerm = (EncodeCore.literalType (ErrorCore.literalTypeMismatchErrorActualType x))}]}) +-- | Encoder for hydra.error.core.MissingCaseBranchesError+missingCaseBranchesError :: ErrorCore.MissingCaseBranchesError -> Core.Term+missingCaseBranchesError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.MissingCaseBranchesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.missingCaseBranchesErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.missingCaseBranchesErrorTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "variantNames"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.name xs)) (ErrorCore.missingCaseBranchesErrorVariantNames x))}]})+ -- | Encoder for hydra.error.core.NestedTermAnnotationError nestedTermAnnotationError :: ErrorCore.NestedTermAnnotationError -> Core.Term nestedTermAnnotationError x =@@ -655,6 +682,22 @@         Core.Field {           Core.fieldName = (Core.Name "actualType"),           Core.fieldTerm = (EncodeCore.type_ (ErrorCore.unexpectedTypeVariantErrorActualType x))}]})++-- | Encoder for hydra.error.core.UnknownCaseAlternativeError+unknownCaseAlternativeError :: ErrorCore.UnknownCaseAlternativeError -> Core.Term+unknownCaseAlternativeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownCaseAlternativeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.unknownCaseAlternativeErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.unknownCaseAlternativeErrorTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.unknownCaseAlternativeErrorName x))}]})  -- | Encoder for hydra.error.core.UnknownPrimitiveNameError unknownPrimitiveNameError :: ErrorCore.UnknownPrimitiveNameError -> Core.Term

@@ -0,0 +1,165 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term encoders for hydra.regex++module Hydra.Encode.Regex where++import qualified Hydra.Core as Core+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Regex as Regex+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++-- | Encoder for hydra.regex.Alternation+alternation :: [Regex.RegexSequence] -> Core.Term+alternation xs = Core.TermList (Lists.map regexSequence xs)++-- | Encoder for hydra.regex.Atom+atom :: Regex.Atom -> Core.Term+atom x =+    case x of+      Regex.AtomLiteral v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "literal"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Regex.AtomAny -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "any"),+          Core.fieldTerm = Core.TermUnit}})+      Regex.AtomAnchorStart -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "anchorStart"),+          Core.fieldTerm = Core.TermUnit}})+      Regex.AtomAnchorEnd -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "anchorEnd"),+          Core.fieldTerm = Core.TermUnit}})+      Regex.AtomGroup v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (alternation v0)}})+      Regex.AtomClass v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Atom"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "class"),+          Core.fieldTerm = (characterClass v0)}})++-- | Encoder for hydra.regex.CharacterClass+characterClass :: Regex.CharacterClass -> Core.Term+characterClass x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.CharacterClass"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "negated"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Regex.characterClassNegated x))},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map classItem xs)) (Regex.characterClassItems x))}]})++-- | Encoder for hydra.regex.CharacterRange+characterRange :: Regex.CharacterRange -> Core.Term+characterRange x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.CharacterRange"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "from"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Regex.characterRangeFrom x))},+        Core.Field {+          Core.fieldName = (Core.Name "to"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Regex.characterRangeTo x))}]})++-- | Encoder for hydra.regex.ClassItem+classItem :: Regex.ClassItem -> Core.Term+classItem x =+    case x of+      Regex.ClassItemCharacter v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.ClassItem"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "character"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Regex.ClassItemRange v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.ClassItem"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "range"),+          Core.fieldTerm = (characterRange v0)}})++-- | Encoder for hydra.regex.Quantified+quantified :: Regex.Quantified -> Core.Term+quantified x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.Quantified"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "atom"),+          Core.fieldTerm = (atom (Regex.quantifiedAtom x))},+        Core.Field {+          Core.fieldName = (Core.Name "quantifier"),+          Core.fieldTerm = (quantifier (Regex.quantifiedQuantifier x))}]})++-- | Encoder for hydra.regex.Quantifier+quantifier :: Regex.Quantifier -> Core.Term+quantifier x =+    case x of+      Regex.QuantifierOne -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "one"),+          Core.fieldTerm = Core.TermUnit}})+      Regex.QuantifierZeroOrOne -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "zeroOrOne"),+          Core.fieldTerm = Core.TermUnit}})+      Regex.QuantifierZeroOrMore -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "zeroOrMore"),+          Core.fieldTerm = Core.TermUnit}})+      Regex.QuantifierOneOrMore -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "oneOrMore"),+          Core.fieldTerm = Core.TermUnit}})+      Regex.QuantifierExactly v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "exactly"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Regex.QuantifierAtLeast v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "atLeast"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Regex.QuantifierRange_ v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.regex.Quantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "range"),+          Core.fieldTerm = (quantifierRange v0)}})++-- | Encoder for hydra.regex.QuantifierRange+quantifierRange :: Regex.QuantifierRange -> Core.Term+quantifierRange x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.regex.QuantifierRange"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "min"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Regex.quantifierRangeMin x))},+        Core.Field {+          Core.fieldName = (Core.Name "max"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Regex.quantifierRangeMax x))}]})++-- | Encoder for hydra.regex.Regex+regex :: Regex.Alternation -> Core.Term+regex = alternation++-- | Encoder for hydra.regex.RegexSequence+regexSequence :: [Regex.Quantified] -> Core.Term+regexSequence xs = Core.TermList (Lists.map quantified xs)

@@ -34,6 +34,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Predicates as Predicates import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Scoping as Scoping

@@ -32,6 +32,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Scoping as Scoping import qualified Hydra.Sorting as Sorting

@@ -243,6 +243,8 @@   InvalidTermErrorInvalidLetBindingName InvalidLetBindingNameError |   -- | A type lambda parameter name violating naming conventions (optional)   InvalidTermErrorInvalidTypeLambdaParameterName InvalidTypeLambdaParameterNameError |+  -- | A case statement that does not cover every variant of the union it matches+  InvalidTermErrorMissingCaseBranches MissingCaseBranchesError |   -- | Nested term annotations that should be merged (optional)   InvalidTermErrorNestedTermAnnotation NestedTermAnnotationError |   -- | A no-op unwrap-of-wrap round-trip (optional)@@ -261,6 +263,8 @@   InvalidTermErrorUndefinedTypeVariableInLambdaDomain UndefinedTypeVariableInLambdaDomainError |   -- | An unbound type variable in a type application term   InvalidTermErrorUndefinedTypeVariableInTypeApplication UndefinedTypeVariableInTypeApplicationError |+  -- | A case statement alternative naming a field that does not exist in the union it matches+  InvalidTermErrorUnknownCaseAlternative UnknownCaseAlternativeError |   -- | A reference to an unknown primitive function   InvalidTermErrorUnknownPrimitiveName UnknownPrimitiveNameError |   -- | An identity lambda applied to an argument (optional)@@ -291,6 +295,8 @@  _InvalidTermError_invalidTypeLambdaParameterName = Core.Name "invalidTypeLambdaParameterName" +_InvalidTermError_missingCaseBranches = Core.Name "missingCaseBranches"+ _InvalidTermError_nestedTermAnnotation = Core.Name "nestedTermAnnotation"  _InvalidTermError_redundantWrapUnwrap = Core.Name "redundantWrapUnwrap"@@ -309,6 +315,8 @@  _InvalidTermError_undefinedTypeVariableInTypeApplication = Core.Name "undefinedTypeVariableInTypeApplication" +_InvalidTermError_unknownCaseAlternative = Core.Name "unknownCaseAlternative"+ _InvalidTermError_unknownPrimitiveName = Core.Name "unknownPrimitiveName"  _InvalidTermError_unnecessaryIdentityApplication = Core.Name "unnecessaryIdentityApplication"@@ -422,6 +430,25 @@  _LiteralTypeMismatchError_actualType = Core.Name "actualType" +-- | A case statement without a default branch that fails to cover every variant of the union it matches+data MissingCaseBranchesError =+  MissingCaseBranchesError {+    -- | The path to the case statement within the term+    missingCaseBranchesErrorLocation :: Paths.SubtermPath,+    -- | The name of the union type being matched+    missingCaseBranchesErrorTypeName :: Core.Name,+    -- | The names of the uncovered variants+    missingCaseBranchesErrorVariantNames :: [Core.Name]}+  deriving (Eq, Ord, Read, Show)++_MissingCaseBranchesError = Core.Name "hydra.error.core.MissingCaseBranchesError"++_MissingCaseBranchesError_location = Core.Name "location"++_MissingCaseBranchesError_typeName = Core.Name "typeName"++_MissingCaseBranchesError_variantNames = Core.Name "variantNames"+ -- | A term annotation directly wrapping another term annotation; annotations should be merged (optional) data NestedTermAnnotationError =   NestedTermAnnotationError {@@ -683,6 +710,25 @@ _UnexpectedTypeVariantError_expectedVariant = Core.Name "expectedVariant"  _UnexpectedTypeVariantError_actualType = Core.Name "actualType"++-- | A case statement alternative naming a field that does not exist in the union it matches+data UnknownCaseAlternativeError =+  UnknownCaseAlternativeError {+    -- | The path to the case statement within the term+    unknownCaseAlternativeErrorLocation :: Paths.SubtermPath,+    -- | The name of the union type being matched+    unknownCaseAlternativeErrorTypeName :: Core.Name,+    -- | The unknown alternative name+    unknownCaseAlternativeErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)++_UnknownCaseAlternativeError = Core.Name "hydra.error.core.UnknownCaseAlternativeError"++_UnknownCaseAlternativeError_location = Core.Name "location"++_UnknownCaseAlternativeError_typeName = Core.Name "typeName"++_UnknownCaseAlternativeError_name = Core.Name "name"  -- | A primitive function reference to a name not in the known primitive registry data UnknownPrimitiveNameError =

@@ -31,10 +31,11 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular@@ -64,7 +65,7 @@       Core.IntegerValueBigint v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "bigint",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract a binary data value from a term binary :: Graph.Graph -> Core.Term -> Either Errors.Error B.ByteString@@ -77,7 +78,7 @@       Core.LiteralBinary v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "binary",-        Errors.unexpectedShapeErrorActual = (ShowCore.literal v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.literal v)})))  -- | Extract a boolean value from a term boolean :: Graph.Graph -> Core.Term -> Either Errors.Error Bool@@ -90,7 +91,7 @@       Core.LiteralBoolean v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "boolean",-        Errors.unexpectedShapeErrorActual = (ShowCore.literal v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.literal v)})))  -- | Extract case statement from a term cases :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error Core.CaseStatement@@ -98,10 +99,10 @@     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)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "case statement",-        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Extract an arbitrary-precision decimal value from a term decimal :: Graph.Graph -> Core.Term -> Either Errors.Error Sci.Scientific@@ -114,7 +115,7 @@       Core.LiteralDecimal v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "decimal",-        Errors.unexpectedShapeErrorActual = (ShowCore.literal v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.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)@@ -172,7 +173,7 @@       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)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Extract the left and right types from an either type eitherType :: Core.Type -> Either Errors.Error Core.EitherType@@ -183,7 +184,7 @@         Core.TypeEither v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "either type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.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@@ -209,7 +210,7 @@       Core.FloatValueFloat32 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "float32",-        Errors.unexpectedShapeErrorActual = (ShowCore.float v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.float v)})))  -- | Extract a 64-bit floating-point value from a term float64 :: Graph.Graph -> Core.Term -> Either Errors.Error Double@@ -222,7 +223,7 @@       Core.FloatValueFloat64 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "float64",-        Errors.unexpectedShapeErrorActual = (ShowCore.float v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.float v)})))  -- | Extract a floating-point literal from a Literal value floatLiteral :: Core.Literal -> Either Errors.Error Core.FloatValue@@ -231,7 +232,7 @@       Core.LiteralFloat v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "floating-point value",-        Errors.unexpectedShapeErrorActual = (ShowCore.literal lit)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.literal lit)})))  -- | Extract a float value from a term floatValue :: Graph.Graph -> Core.Term -> Either Errors.Error Core.FloatValue@@ -246,7 +247,7 @@         Core.TypeFunction v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "function type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.type_ typ)})))  -- | Extract a field from a union term injection :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Field@@ -257,7 +258,7 @@         Errors.unexpectedShapeErrorActual = (Core.unName (Core.injectionTypeName v0))}))))       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "injection",-        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Extract a 16-bit signed integer value from a term int16 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int16@@ -270,7 +271,7 @@       Core.IntegerValueInt16 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "int16",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract a 32-bit signed integer value from a term int32 :: Graph.Graph -> Core.Term -> Either Errors.Error Int@@ -283,7 +284,7 @@       Core.IntegerValueInt32 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "int32",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract a 64-bit signed integer value from a term int64 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int64@@ -296,7 +297,7 @@       Core.IntegerValueInt64 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "int64",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract an 8-bit signed integer value from a term int8 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int8@@ -309,7 +310,7 @@       Core.IntegerValueInt8 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "int8",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract an integer literal from a Literal value integerLiteral :: Core.Literal -> Either Errors.Error Core.IntegerValue@@ -318,7 +319,7 @@       Core.LiteralInteger v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "integer value",-        Errors.unexpectedShapeErrorActual = (ShowCore.literal lit)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.literal lit)})))  -- | Extract an integer value from a term integerValue :: Graph.Graph -> Core.Term -> Either Errors.Error Core.IntegerValue@@ -331,7 +332,7 @@       Core.TermLambda v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "lambda",-        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Extract the body of a lambda term lambdaBody :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Term@@ -344,7 +345,7 @@       Core.TermLet v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "let term",-        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Extract a binding with the given name from a let term letBinding :: String -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Term@@ -367,7 +368,7 @@       Core.TermList v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "list",-        Errors.unexpectedShapeErrorActual = (ShowCore.term stripped)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term stripped)}))))  -- | 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]@@ -382,7 +383,7 @@         Core.TypeList v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "list type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.type_ typ)})))  -- | Extract a literal value from a term literal :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Literal@@ -391,7 +392,7 @@       Core.TermLiteral v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "literal",-        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.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))@@ -406,7 +407,7 @@         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)})))))+          Errors.unexpectedShapeErrorActual = (PrintCore.term term)})))))  -- | Extract the key and value types from a map type mapType :: Core.Type -> Either Errors.Error Core.MapType@@ -417,7 +418,7 @@         Core.TypeMap v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "map type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.type_ typ)})))  -- | Ensure a function has the expected number of arguments nArgs :: Core.Name -> Int -> [t0] -> Either Errors.Error ()@@ -436,7 +437,7 @@       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)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Extract the base type from an optional type optionalType :: Core.Type -> Either Errors.Error Core.Type@@ -447,7 +448,7 @@         Core.TypeOptional v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "optional type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.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)@@ -456,7 +457,7 @@       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)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Extract a record's fields from a term record :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error [Core.Field]@@ -474,7 +475,7 @@         Core.TypeRecord v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "record type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.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@@ -491,7 +492,7 @@       Core.TermSet v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "set",-        Errors.unexpectedShapeErrorActual = (ShowCore.term stripped)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.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))@@ -506,7 +507,7 @@         Core.TypeSet v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "set type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.type_ typ)})))  -- | Extract a string value from a term string :: Graph.Graph -> Core.Term -> Either Errors.Error String@@ -519,12 +520,12 @@       Core.LiteralString v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "string",-        Errors.unexpectedShapeErrorActual = (ShowCore.literal v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.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)+    Eithers.bimap (\_e -> Errors.DecodingError (PrintErrors.error _e)) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)  -- | Extract a record from a term termRecord :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Record@@ -533,7 +534,7 @@       Core.TermRecord v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "record",-        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Convert a Record's fields to a Map from Name to Term toFieldMap :: Core.Record -> M.Map Core.Name Core.Term@@ -550,7 +551,7 @@       Core.IntegerValueUint16 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "uint16",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract a 32-bit unsigned integer value from a term uint32 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int64@@ -563,7 +564,7 @@       Core.IntegerValueUint32 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "uint32",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract a 64-bit unsigned integer value from a term uint64 :: Graph.Graph -> Core.Term -> Either Errors.Error Integer@@ -576,7 +577,7 @@       Core.IntegerValueUint64 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "uint64",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract an 8-bit unsigned integer value from a term uint8 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int16@@ -589,7 +590,7 @@       Core.IntegerValueUint8 v0 -> Right v0       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "uint8",-        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.integer v)})))  -- | Extract the field types from a union type unionType :: t0 -> Core.Type -> Either Errors.Error [Core.FieldType]@@ -600,7 +601,7 @@         Core.TypeUnion v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "union type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.type_ typ)})))  -- | Extract a unit value from a term unit :: Core.Term -> Either Errors.Error ()@@ -609,7 +610,7 @@       Core.TermUnit -> Right ()       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "unit",-        Errors.unexpectedShapeErrorActual = (ShowCore.term term)})))+        Errors.unexpectedShapeErrorActual = (PrintCore.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@@ -625,7 +626,7 @@         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)}))))+        Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))  -- | Extract the wrapped type from a wrapper type wrappedType :: t0 -> Core.Type -> Either Errors.Error Core.Type@@ -636,4 +637,4 @@         Core.TypeWrap v0 -> Right v0         _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "wrapped type",-          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.type_ typ)})))

@@ -26,6 +26,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -24,9 +24,10 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational-import qualified Hydra.Show.Errors as ShowErrors import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing

@@ -31,6 +31,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -33,6 +33,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Resolution as Resolution import qualified Hydra.Rewriting as Rewriting

@@ -36,15 +36,16 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors+import qualified Hydra.Print.Typing as PrintTyping import qualified Hydra.Query as Query import qualified Hydra.Reflect as Reflect+import qualified Hydra.Regex as Regex 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.System as System@@ -164,7 +165,7 @@           cx2 = Pairs.second result       in (Core.TypeVariable name, cx2) --- | Generalize a type to a type scheme+-- | Generalize a type to a type scheme. Paper: inference.tex, gen() and rule Gen. generalize :: Graph.Graph -> Core.Type -> Core.TypeScheme generalize cx typ = @@ -188,7 +189,7 @@ 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.+-- | Infer types for all elements in a graph, using the provided ordered bindings. Returns both the inferred graph and the ordered inferred bindings. Paper: inference.tex, the SCC treatment of cycles (section introduction); the whole graph is one mutually recursive let. inferGraphTypes :: Typing.InferenceContext -> [Core.Binding] -> Graph.Graph -> Either Errors.Error ((Graph.Graph, [Core.Binding]), Typing.InferenceContext) inferGraphTypes fcx0 bindings0 g0 = @@ -288,7 +289,7 @@               (Literals.showInt32 (Lists.length bindings)),               " bindings"])})))))))))) --- | Infer the type of an annotated term (Either version)+-- | Infer the type of an annotated term (Either version). Paper: inference.tex, rule Ann. inferTypeOfAnnotatedTerm :: Typing.InferenceContext -> Graph.Graph -> Core.AnnotatedTerm -> Either Errors.Error Typing.InferenceResult inferTypeOfAnnotatedTerm fcx cx at = @@ -310,7 +311,7 @@           Typing.inferenceResultClassConstraints = iconstraints,           Typing.inferenceResultContext = fcx2})))) --- | Infer the type of a function application (Either version)+-- | Infer the type of a function application (Either version). Paper: inference.tex, rule App (elaboration form). inferTypeOfApplication :: Typing.InferenceContext -> Graph.Graph -> Core.Application -> Either Errors.Error Typing.InferenceResult inferTypeOfApplication fcx0 cx app = @@ -358,7 +359,7 @@               Typing.inferenceResultClassConstraints = rConstraints,               Typing.inferenceResultContext = fcx4}))))))))) --- | Infer the type of a case statement (Either version)+-- | Infer the type of a case statement (Either version). Paper: inference.tex, rules Case and Case_d. inferTypeOfCaseStatement :: Typing.InferenceContext -> Graph.Graph -> Core.CaseStatement -> Either Errors.Error Typing.InferenceResult inferTypeOfCaseStatement fcx cx caseStmt = @@ -427,7 +428,7 @@                 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.+-- | Infer the type of a collection. The classNames parameter specifies type classes (e.g. ordering) that the element type variable must satisfy. Paper: inference.tex, shared implementation of the collection introduction rules (Lst_0/Lst_+, Set_0/Set_+). 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 = @@ -459,7 +460,7 @@               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)+-- | Infer the type of an either value (Either version). Paper: inference.tex, rules Eith_L and Eith_R. 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 ->@@ -506,7 +507,7 @@                     Core.eitherTypeRight = rightType})       in (Right (yieldChecked fcx3 termWithBothTypes eitherType subst)))) e --- | Infer the type of a union injection (Either version)+-- | Infer the type of a union injection (Either version). Paper: inference.tex, rule Inj. inferTypeOfInjection :: Typing.InferenceContext -> Graph.Graph -> Core.Injection -> Either Errors.Error Typing.InferenceResult inferTypeOfInjection fcx cx injection = @@ -535,7 +536,7 @@               Typing.typeConstraintRight = ityp,               Typing.typeConstraintComment = "schema type of injected field"}]) (\mcResult -> Right mcResult)))))))) --- | Infer the type of a lambda function (Either version)+-- | Infer the type of a lambda function (Either version). Paper: inference.tex, rule Abs (elaboration form). inferTypeOfLambda :: Typing.InferenceContext -> Graph.Graph -> Core.Lambda -> Either Errors.Error Typing.InferenceResult inferTypeOfLambda fcx cx lambda = @@ -583,7 +584,7 @@           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.+-- | 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. Paper: inference.tex, the SCC treatment of cycles (section introduction) and the remark following the elaboration-form Let rule. inferTypeOfLet :: Typing.InferenceContext -> Graph.Graph -> Core.Let -> Either Errors.Error Typing.InferenceResult inferTypeOfLet fcx0 cx let0 = @@ -644,7 +645,7 @@                     _ -> 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)+-- | Infer the type of a let (letrec) term which is already in a normal form (Either version). Paper: inference.tex, rule Let (elaboration form). inferTypeOfLetNormalized :: Typing.InferenceContext -> Graph.Graph -> Core.Let -> Either Errors.Error Typing.InferenceResult inferTypeOfLetNormalized fcx0 cx0 letTerm = @@ -734,12 +735,12 @@               Typing.inferenceResultClassConstraints = allConstraints,               Typing.inferenceResultContext = fcx4}))))))))) --- | Infer the type of a list (Either version)+-- | Infer the type of a list (Either version). Paper: inference.tex, rules Lst_0 and Lst_+. 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+-- | Infer the type of a literal. Paper: inference.tex, rule Lit. inferTypeOfLiteral :: Typing.InferenceContext -> Core.Literal -> Typing.InferenceResult inferTypeOfLiteral fcx lit =     Typing.InferenceResult {@@ -749,7 +750,7 @@       Typing.inferenceResultClassConstraints = Maps.empty,       Typing.inferenceResultContext = fcx} --- | Infer the type of a map (Either version)+-- | Infer the type of a map (Either version). Paper: inference.tex, rules Map_0 and Map_+. inferTypeOfMap :: Typing.InferenceContext -> Graph.Graph -> M.Map Core.Term Core.Term -> Either Errors.Error Typing.InferenceResult inferTypeOfMap fcx cx m = @@ -801,14 +802,14 @@             kcons,             vcons])) (\mcResult -> Right mcResult))))))) --- | Infer the type of a Maybe value+-- | Infer the type of a Maybe value. Paper: inference.tex, rules Opt_0 and Opt_1. 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)+-- | Infer the type of a pair (Either version). Paper: inference.tex, rule Pair. inferTypeOfPair :: Typing.InferenceContext -> Graph.Graph -> (Core.Term, Core.Term) -> Either Errors.Error Typing.InferenceResult inferTypeOfPair fcx cx p =     Eithers.bind (inferMany fcx cx [@@ -832,18 +833,7 @@           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)+-- | Infer the type of a record projection (Either version). Paper: inference.tex, rule Proj. inferTypeOfProjection :: Typing.InferenceContext -> Graph.Graph -> Core.Projection -> Either Errors.Error Typing.InferenceResult inferTypeOfProjection fcx cx proj = @@ -860,7 +850,7 @@           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)+-- | Infer the type of a record (Either version). Paper: inference.tex, rule Rec. inferTypeOfRecord :: Typing.InferenceContext -> Graph.Graph -> Core.Record -> Either Errors.Error Typing.InferenceResult inferTypeOfRecord fcx cx record = @@ -893,7 +883,7 @@               Typing.typeConstraintRight = ityp,               Typing.typeConstraintComment = "schema type of record"}]) (\mcResult -> Right mcResult)))))) --- | Infer the type of a set (Either version)+-- | Infer the type of a set (Either version). Paper: inference.tex, rules Set_0 and Set_+. 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)@@ -926,7 +916,7 @@         Core.TermVariable v0 -> inferTypeOfVariable fcx2 cx v0         Core.TermWrap v0 -> inferTypeOfWrappedTerm fcx2 cx v0 --- | Infer the type of a type application (Either version)+-- | Infer the type of a type application (Either version). Paper: inference.tex, type application terms in the elaborated Term grammar. inferTypeOfTypeApplication :: Typing.InferenceContext -> Graph.Graph -> Core.TypeApplicationTerm -> Either Errors.Error Typing.InferenceResult inferTypeOfTypeApplication fcx cx tt = @@ -940,7 +930,7 @@           Typing.inferenceResultClassConstraints = (Typing.inferenceResultClassConstraints result),           Typing.inferenceResultContext = fcx2})))) --- | Infer the type of a type abstraction (Either version)+-- | Infer the type of a type abstraction (Either version). Paper: inference.tex, type abstraction terms in the elaborated Term grammar. inferTypeOfTypeLambda :: Typing.InferenceContext -> Graph.Graph -> Core.TypeLambda -> Either Errors.Error Typing.InferenceResult inferTypeOfTypeLambda fcx cx ta = @@ -954,7 +944,7 @@           Typing.inferenceResultClassConstraints = (Typing.inferenceResultClassConstraints result),           Typing.inferenceResultContext = fcx2})))) --- | The trivial inference rule for the unit term+-- | The trivial inference rule for the unit term. Paper: inference.tex, rule Unit. inferTypeOfUnit :: Typing.InferenceContext -> Typing.InferenceResult inferTypeOfUnit fcx =     Typing.InferenceResult {@@ -964,7 +954,7 @@       Typing.inferenceResultClassConstraints = Maps.empty,       Typing.inferenceResultContext = fcx} --- | Infer the type of an unwrap operation (Either version)+-- | Infer the type of an unwrap operation (Either version). Paper: inference.tex, rule Unwr. 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 ->@@ -976,7 +966,7 @@         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)+-- | Infer the type of a variable (Either version). Paper: inference.tex, rule Var (elaboration form), with rule Prim as the primitive-namespace fallback. 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 {@@ -997,7 +987,7 @@         Typing.inferenceResultClassConstraints = constraints,         Typing.inferenceResultContext = fcx2}))) --- | Infer the type of a wrapped term (Either version)+-- | Infer the type of a wrapped term (Either version). Paper: inference.tex, rule Wrp. inferTypeOfWrappedTerm :: Typing.InferenceContext -> Graph.Graph -> Core.WrappedTerm -> Either Errors.Error Typing.InferenceResult inferTypeOfWrappedTerm fcx cx wt = @@ -1102,11 +1092,11 @@           subst = Typing.inferenceResultSubst result       in (Strings.cat [         "{term=",-        (ShowCore.term term),+        (PrintCore.term term),         ", type=",-        (ShowCore.type_ typ),+        (PrintCore.type_ typ),         ", subst=",-        (ShowTyping.typeSubst subst),+        (PrintTyping.typeSubst subst),         "}"])  -- | Create an inference result with no class constraints

@@ -31,9 +31,10 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational-import qualified Hydra.Show.Core as ShowCore import qualified Hydra.Strip as Strip import qualified Hydra.Substitution as Substitution import qualified Hydra.System as System@@ -186,7 +187,7 @@                           Core.applicationTypeArgument = arg})))                       _ -> Left (Strings.cat [                         "cannot apply a non-parametric type: ",-                        (ShowCore.type_ fn)])+                        (PrintCore.type_ fn)])       in case stripped of         Core.TypeApplication v0 -> Eithers.either (\err -> Left err) (\reducedType -> fromJson types tname reducedType value) (reduceApp v0)         Core.TypeForall v0 -> fromJson types tname (Core.forallTypeBody v0) value@@ -333,7 +334,7 @@             (Core.unName v0)])) (\resolvedType -> fromJson types v0 resolvedType value))         _ -> Left (Strings.cat [           "unsupported type for JSON decoding: ",-          (ShowCore.type_ typ)])+          (PrintCore.type_ typ)])  -- | Parse an IEEE sentinel string (NaN, Infinity, -Infinity, -0.0) to a float64. Returns Nothing for unrecognized strings. parseSpecialFloat :: String -> Maybe Double

@@ -25,6 +25,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -32,9 +32,10 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational-import qualified Hydra.Show.Core as ShowCore import qualified Hydra.Strip as Strip import qualified Hydra.Substitution as Substitution import qualified Hydra.System as System@@ -116,7 +117,7 @@                           Core.applicationTypeArgument = arg})))                       _ -> Left (Strings.cat [                         "cannot apply a non-parametric type: ",-                        (ShowCore.type_ fn)])+                        (PrintCore.type_ fn)])       in case stripped of         Core.TypeApplication v0 -> Eithers.either (\err -> Left err) (\reducedType -> toJson types tname reducedType term) (reduceApp v0)         Core.TypeForall v0 -> toJson types tname (Core.forallTypeBody v0) term@@ -247,7 +248,7 @@           in (Optionals.cases lookedUp (toJsonUntyped term) (\resolvedType -> toJson types v0 resolvedType term))         _ -> Left (Strings.cat [           "unsupported type for JSON encoding: ",-          (ShowCore.type_ typ)])+          (PrintCore.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@@ -321,4 +322,4 @@             ("right", v)]) encodedR)) v0         _ -> Left (Strings.cat [           "unsupported term variant for JSON encoding: ",-          (ShowCore.term term)])+          (PrintCore.term term)])

@@ -28,6 +28,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -29,6 +29,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.Serialization as Serialization import qualified Hydra.System as System

@@ -26,6 +26,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -26,6 +26,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -6,12 +6,12 @@ - Hydra.Encode.Core - Hydra.Extract.Core - Hydra.Extract.Util-- Hydra.Show.Variants+- Hydra.Print.Variants - Hydra.Codegen - Hydra.Json.Parser - Hydra.Json.Writer - Hydra.Parsers-- Hydra.Show.Core+- Hydra.Print.Core - Hydra.Topology -} 

@@ -23,6 +23,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query import qualified Hydra.Reflect as Reflect+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -31,11 +31,12 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths+import qualified Hydra.Print.Core as PrintCore+import qualified Hydra.Print.Errors as PrintErrors import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex 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.System as System import qualified Hydra.Tabular as Tabular@@ -213,7 +214,7 @@         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)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.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@@ -232,10 +233,10 @@                       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)})))))+            Errors.unexpectedShapeErrorActual = (PrintCore.term term)})))))         _ -> Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = (Strings.cat2 "injection for type " (Core.unName tname)),-          Errors.unexpectedShapeErrorActual = (ShowCore.term stripped)})))+          Errors.unexpectedShapeErrorActual = (PrintCore.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))

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -35,6 +36,34 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +isAlpha :: Packaging.PrimitiveDefinition+isAlpha =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.chars.isAlpha"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether a character is alphabetic."),+        Packaging.entityMetadataComments = [+          "True if the argument is a Unicode letter \8212 any of the general categories L* (Lu, Ll, Lt, Lm, Lo) \8212 and 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).",+          "Alphabetic is broader than cased: letters in scripts without a case distinction are included. isAlphaNum is true whenever isAlpha is true.",+          "Total. Corresponds to Haskell's Data.Char.isAlpha :: 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}+ isAlphaNum :: Packaging.PrimitiveDefinition isAlphaNum =     Packaging.PrimitiveDefinition {@@ -46,6 +75,33 @@           "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}++isDigit :: Packaging.PrimitiveDefinition+isDigit =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.chars.isDigit"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether a character is an ASCII decimal digit."),+        Packaging.entityMetadataComments = [+          "True if the argument is one of the ten code points '0' through '9' (U+0030 to U+0039), and false otherwise.",+          "Unlike the other predicates in this module, this one is deliberately ASCII-only: decimal digits outside the ASCII range (general category Nd) are rejected here, though isAlphaNum accepts them.",+          "Total. Corresponds to Haskell's Data.Char.isDigit :: Char -> Bool."],         Packaging.entityMetadataSeeAlso = [],         Packaging.entityMetadataLifecycle = Nothing})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {

@@ -14,6 +14,26 @@ defaultImplementations =     M.fromList [       (+        Core.Name "hydra.lib.eithers.apply",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "ef"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "ex"),+            Core.lambdaDomain = Nothing,+            Core.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 "ef"))})),+              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.eithers.map")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "ex"))}))}))}))}))}))),+      (         Core.Name "hydra.lib.eithers.bimap",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "f"),@@ -60,6 +80,59 @@                 Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),               Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))),       (+        Core.Name "hydra.lib.eithers.compose",+        (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.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.TermVariable (Core.Name "g"))}))}))}))}))),+      (+        Core.Name "hydra.lib.eithers.foldList",+        (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.Name "hydra.lib.eithers.foldl",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "f"),@@ -350,6 +423,56 @@                   Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),                   Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))}))}))),       (+        Core.Name "hydra.lib.eithers.partition",+        (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.Name "hydra.lib.eithers.partitionEithers",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "xs"),@@ -400,6 +523,12 @@               Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})),             Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))),       (+        Core.Name "hydra.lib.eithers.pure",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "x"))))}))),+      (         Core.Name "hydra.lib.eithers.rights",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "xs"),@@ -478,6 +607,21 @@                 Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),               Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))}))),       (+        Core.Name "hydra.lib.equality.notEqual",+        (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.TermVariable (Core.Name "hydra.lib.logic.not")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.equal")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))}))}))),+      (         Core.Name "hydra.lib.lists.bind",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "xs"),@@ -690,6 +834,21 @@                 Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})),               Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))),       (+        Core.Name "hydra.lib.lists.takeWhile",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "p"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "xs"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.span")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "p"))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))}))),+      (         Core.Name "hydra.lib.logic.and",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "a"),@@ -1047,6 +1206,43 @@                     Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})),                 Core.applicationArgument = (Core.TermVariable (Core.Name "g"))}))}))}))}))),       (+        Core.Name "hydra.lib.optionals.foldList",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "acc"),+            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 "m"),+                      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.TermVariable (Core.Name "hydra.lib.optionals.bind")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),+                          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 "f")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))}))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.pure")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))}))),+      (         Core.Name "hydra.lib.optionals.fromOptional",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "def"),@@ -1065,6 +1261,37 @@                 Core.lambdaDomain = Nothing,                 Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))}))}))}))),       (+        Core.Name "hydra.lib.optionals.givens",+        (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.Name "hydra.lib.optionals.isGiven",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "m"),@@ -1115,6 +1342,49 @@                   Core.applicationFunction = (Core.TermVariable (Core.Name "f")),                   Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))))}))}))}))}))),       (+        Core.Name "hydra.lib.optionals.mapList",+        (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.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.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.optionals.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.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.pure")),+                  Core.applicationArgument = (Core.TermList [])}))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))),+      (         Core.Name "hydra.lib.optionals.mapOptional",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "f"),@@ -1130,6 +1400,60 @@                   Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),                 Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))}))),       (+        Core.Name "hydra.lib.optionals.mapSet",+        (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.optionals.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.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.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.optionals.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.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.pure")),+                    Core.applicationArgument = (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.Name "hydra.lib.optionals.pure",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "x"),@@ -1152,6 +1476,24 @@               Core.lambdaBody = (Core.TermList [                 Core.TermVariable (Core.Name "x")])}))}))}))),       (+        Core.Name "hydra.lib.optionals.withDefault",+        (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.Name "hydra.lib.pairs.bimap",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "f"),@@ -1210,6 +1552,23 @@               Core.applicationArgument = (Core.TermApplication (Core.Application {                 Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "s1"))}))}))}))}))),+      (+        Core.Name "hydra.lib.sets.filter",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "p"),+          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.filter")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "p"))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))}))}))),       (         Core.Name "hydra.lib.sets.intersection",         (Core.TermLambda (Core.Lambda {

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -160,6 +161,52 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +foldList :: Packaging.PrimitiveDefinition+foldList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.effects.foldList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Left-fold over a list with an effect-returning function."),+        Packaging.entityMetadataComments = [+          "foldList(f, acc0, xs) describes an effectful left fold over xs, sequencing applications of f from left to right.",+          "New name for foldl (retained as a deprecated alias until the #417 breaking wave removes it)."],+        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.TypeEffect (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.TypeEffect (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = False,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+ foldl :: Packaging.PrimitiveDefinition foldl =     Packaging.PrimitiveDefinition {@@ -316,6 +363,47 @@         Typing.termSignatureResult = Typing.Result {           Typing.resultDescription = Nothing,           Typing.resultType = (Core.TypeEffect (Core.TypeOptional (Core.TypeVariable (Core.Name "y"))))}},+      Packaging.primitiveDefinitionIsPure = False,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}++mapSet :: Packaging.PrimitiveDefinition+mapSet =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.effects.mapSet"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map an effect-returning function over a set."),+        Packaging.entityMetadataComments = [+          "mapSet(f, s) describes an effectful computation which applies f to each element of s, sequencing the effects in ascending element order (the order is normative, since the effects are observable), and collects the results as a set, deduplicated by the result type's ordering.",+          "Requires 'ordering' constraints on both element types (the set type contract)."],+        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.TypeEffect (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.TypeEffect (Core.TypeSet (Core.TypeVariable (Core.Name "y"))))}},       Packaging.primitiveDefinitionIsPure = False,       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing}

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -35,6 +36,73 @@ 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.eithers.apply"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Applicative apply for either: combine a function under either and an argument under either."),+        Packaging.entityMetadataComments = [+          "apply(ef, ex) returns right(f(x)) when ef is right(f) and ex is right(x).",+          "If either argument is a left, the result is that left; when both arguments are left, the first (function-side) left is returned \8212 first error wins, and ex is not consulted once ef is known to be a left.",+          "apply(ef, ex) is bind(ef, \\f -> map(f, ex)); this defining equation is the specification, and the default implementation.",+          "Total. Corresponds to Haskell's (<*>) :: Either a (b -> c) -> Either a b -> 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.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.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 "x")),+            Core.eitherTypeRight = (Core.TypeVariable (Core.Name "z"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "ef"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "ex"),+          Core.lambdaDomain = Nothing,+          Core.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 "ef"))})),+            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.eithers.map")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "ex"))}))}))}))}))})))}+ bimap :: Packaging.PrimitiveDefinition bimap =     Packaging.PrimitiveDefinition {@@ -180,6 +248,80 @@               Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),             Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))})))} +compose :: Packaging.PrimitiveDefinition+compose =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.compose"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Kleisli composition for either."),+        Packaging.entityMetadataComments = [+          "compose(f, g, x) is bind(f(x), g); this defining equation is the specification, and the default implementation.",+          "If either f(x) or the second stage produces a left, the result is that left.",+          "Total. Corresponds to Kleisli composition (>=>) specialised to Either with a fixed Left type."],+        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.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "w")),+                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 "w")),+                Core.eitherTypeRight = (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.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "w")),+            Core.eitherTypeRight = (Core.TypeVariable (Core.Name "z"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (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.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.TermVariable (Core.Name "g"))}))}))}))})))}+ either :: Packaging.PrimitiveDefinition either =     Packaging.PrimitiveDefinition {@@ -232,6 +374,92 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +foldList :: Packaging.PrimitiveDefinition+foldList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.foldList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Left-fold over a list with an Either-returning function, short-circuiting on Left."),+        Packaging.entityMetadataComments = [+          "foldList(f, acc0, xs) folds f over xs from the left, threading an accumulator of type a, where each application may fail with Left e: it iterates while f returns Right, propagates Left on the first failure, and returns Right (final accumulator) if all elements were processed.",+          "New name for foldl (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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.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"))}))}))}))})))}+ foldl :: Packaging.PrimitiveDefinition foldl =     Packaging.PrimitiveDefinition {@@ -911,6 +1139,90 @@                 Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))}))})))} +partition :: Packaging.PrimitiveDefinition+partition =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.partition"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Partition a list of either values into lefts and rights."),+        Packaging.entityMetadataComments = [+          "partition(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.",+          "New name for partitionEithers (which is retained as a deprecated alias until the #417 breaking wave removes it).",+          "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.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"))}))})))}+ partitionEithers :: Packaging.PrimitiveDefinition partitionEithers =     Packaging.PrimitiveDefinition {@@ -993,6 +1305,44 @@                     Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))})),             Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})),           Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))})))}++pure :: Packaging.PrimitiveDefinition+pure =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.pure"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Wrap a value as a right."),+        Packaging.entityMetadataComments = [+          "pure(x) is right(x); this defining equation is the specification, and the default implementation.",+          "This is the unit of the either monad; it exists so that code written generically over a monad can reach the unit.",+          "Total. Corresponds to Haskell's pure / Right for 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.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (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 "x")),+            Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "x"))))})))}  rights :: Packaging.PrimitiveDefinition rights =

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -388,3 +389,51 @@                   Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))})),               Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),             Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))})))}++notEqual :: Packaging.PrimitiveDefinition+notEqual =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.notEqual"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether two values are unequal."),+        Packaging.entityMetadataComments = [+          "notEqual(x, y) = logic.not(equal(x, y)); this defining equation is the specification, and the default implementation.",+          "Requires an 'equality' type-class constraint on the argument type.",+          "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 = (Just (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.TermVariable (Core.Name "hydra.lib.logic.not")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.equal")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))}))})))}

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -0,0 +1,240 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Primitives in the hydra.lib.functions module.++module Hydra.Lib.Functions where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Docs as Docs+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.File as ErrorFile+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Error.System as ErrorSystem+import qualified Hydra.Errors as Errors+import qualified Hydra.File as File+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.Regex as Regex+import qualified Hydra.Relational as Relational+import qualified Hydra.System as System+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Time as Time+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++compose :: Packaging.PrimitiveDefinition+compose =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.functions.compose"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compose two functions."),+        Packaging.entityMetadataComments = [+          "compose(g, f, x) = g(f(x)); this defining equation is the specification.",+          "The outer function comes first: f is applied to x, and g is applied to the result.",+          "This is ordinary function composition, distinct from the Kleisli compose primitives of the monad modules.",+          "Total. Corresponds to Haskell's (.) :: (b -> c) -> (a -> b) -> a -> c."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "t1"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "t2"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "t3"),+            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 "t2")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "t3"))})),+            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 "t1")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "t2"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "t1")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "t3"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "g"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          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.TermVariable (Core.Name "g")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}))}))})))}++const :: Packaging.PrimitiveDefinition+const =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.functions.const"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the first argument, ignoring the second."),+        Packaging.entityMetadataComments = [+          "const(x, y) = x; this defining equation is the specification.",+          "Partially applied, const(x) is the constant function which returns x on every input.",+          "Total. Corresponds to Haskell's const :: a -> b -> a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "t1"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "t2"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "t1")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "t2")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "t1"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (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.TermVariable (Core.Name "x"))}))})))}++flip :: Packaging.PrimitiveDefinition+flip =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.functions.flip"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Swap the argument order of a binary function."),+        Packaging.entityMetadataComments = [+          "flip(f, x, y) = f(y, x); this defining equation is the specification.",+          "Total. Corresponds to Haskell's flip :: (a -> b -> c) -> b -> a -> c."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "t1"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "t2"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "t3"),+            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 "t1")),+              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t2")),+                Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "t3"))}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "t2")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "t1")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "t3"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "f"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (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.TermVariable (Core.Name "f")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}))})))}++identity :: Packaging.PrimitiveDefinition+identity =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.functions.identity"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the argument unchanged."),+        Packaging.entityMetadataComments = [+          "identity(x) = x; this defining equation is the specification. The polymorphic identity function.",+          "identity is the unit of compose: compose(identity, f) and compose(f, identity) are both f.",+          "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 "t1"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "t1")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "t1"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))}

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular

@@ -21,6 +21,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query+import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular@@ -75,6 +76,41 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +at :: Packaging.PrimitiveDefinition+at =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.at"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the element at the given index, or Nothing if out of bounds."),+        Packaging.entityMetadataComments = [+          "at(i, xs) returns Just(xs[i]) if 0 <= i < length(xs), or Nothing otherwise.",+          "New name for maybeAt (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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}+ bind :: Packaging.PrimitiveDefinition bind =     Packaging.PrimitiveDefinition {@@ -138,6 +174,55 @@               Core.applicationArgument = (Core.TermList [])})),             Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})))} +compose :: Packaging.PrimitiveDefinition+compose =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.compose"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compose two functions that return lists (Kleisli composition in the list monad)."),+        Packaging.entityMetadataComments = [+          "compose(f, g, x) is bind(f(x), g); this defining equation is the specification. The results of applying g to each element of f(x) are concatenated in order.",+          "Total. Corresponds to Kleisli composition (>=>) in the list monad."],+        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.TypeList (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.TypeList (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.TypeList (Core.TypeVariable (Core.Name "z")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+ concat :: Packaging.PrimitiveDefinition concat =     Packaging.PrimitiveDefinition {@@ -235,6 +320,38 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +distinct :: Packaging.PrimitiveDefinition+distinct =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.distinct"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Remove duplicate elements from a list."),+        Packaging.entityMetadataComments = [+          "distinct(xs) returns the list of distinct elements of xs, in the order of their first occurrence.",+          "New name for nub (retained as a deprecated alias until the #417 breaking wave removes it).",+          "Requires an 'equality' constraint on the element type.",+          "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}+ drop :: Packaging.PrimitiveDefinition drop =     Packaging.PrimitiveDefinition {@@ -481,6 +598,53 @@               Core.applicationArgument = (Core.TermOptional Nothing)})),             Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})))} +foldList :: Packaging.PrimitiveDefinition+foldList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.foldList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Left-fold a list in the list monad (a nondeterministic fold)."),+        Packaging.entityMetadataComments = [+          "foldList(f, acc0, xs) folds xs from the left, branching the accumulator over every result of the step function at each element: after each element the set of accumulators is replaced by all results of applying f to each current accumulator and that element.",+          "foldList(f, acc0, xs) is foldl(\\macc el -> bind(macc, \\acc -> f(acc, el)), pure(acc0), xs); this defining equation is the specification. For the empty list the result is pure(acc0).",+          "Total on finite inputs. The list-monad instance of the monadic left fold."],+        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.TypeList (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.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+ foldl :: Packaging.PrimitiveDefinition foldl =     Packaging.PrimitiveDefinition {@@ -605,6 +769,66 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +head :: Packaging.PrimitiveDefinition+head =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.head"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the first element, or Nothing if the list is empty."),+        Packaging.entityMetadataComments = [+          "head(xs) returns Just(x) where x is the first element of xs, or Nothing if xs is empty.",+          "New name for maybeHead (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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}++init :: Packaging.PrimitiveDefinition+init =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.init"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return all elements except the last, or Nothing if the list is empty."),+        Packaging.entityMetadataComments = [+          "init(xs) returns Just(ys) where ys is xs with its last element removed, or Nothing if xs is empty.",+          "New name for maybeInit (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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}+ intercalate :: Packaging.PrimitiveDefinition intercalate =     Packaging.PrimitiveDefinition {@@ -673,6 +897,71 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +join :: Packaging.PrimitiveDefinition+join =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.join"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Intercalate a list of lists with a separator list between each."),+        Packaging.entityMetadataComments = [+          "join(sep, xss) returns the concatenation of xss with sep inserted between consecutive lists. Equivalent to concat(intersperse(sep, xss)).",+          "New name for intercalate (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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}++last :: Packaging.PrimitiveDefinition+last =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.last"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the last element, or Nothing if the list is empty."),+        Packaging.entityMetadataComments = [+          "last(xs) returns Just(x) where x is the last element of xs, or Nothing if xs is empty.",+          "New name for maybeLast (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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}+ length :: Packaging.PrimitiveDefinition length =     Packaging.PrimitiveDefinition {@@ -742,6 +1031,127 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +mapList :: Packaging.PrimitiveDefinition+mapList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.mapList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Traverse a list in the list monad."),+        Packaging.entityMetadataComments = [+          "mapList(f, xs) returns all combinations obtainable by choosing one element from f(x) for each x in xs: each result list has the same length as xs, with its element at each position drawn from the corresponding f(x).",+          "Results appear in the lexicographic order of the choices, with the choice for the first element varying slowest. The number of results is the product of the lengths of the lists f(x); if f(x) is empty for any element, the result is the empty list; mapList(f, []) is pure([]).",+          "Total on finite inputs. The list-monad instance of the traversal family."],+        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.TypeList (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.TypeList (Core.TypeVariable (Core.Name "y"))))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}++mapOptional :: Packaging.PrimitiveDefinition+mapOptional =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.mapOptional"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Traverse an optional value in the list monad."),+        Packaging.entityMetadataComments = [+          "mapOptional(f, m) returns the single-element list containing none when m is none; for given(x) it returns given(y) for each element y of f(x), in order.",+          "Total on finite inputs. The list-monad instance of the traversal family, applied to the optional container."],+        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.TypeList (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.TypeList (Core.TypeOptional (Core.TypeVariable (Core.Name "y"))))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}++mapSet :: Packaging.PrimitiveDefinition+mapSet =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.mapSet"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Traverse a set in the list monad."),+        Packaging.entityMetadataComments = [+          "mapSet(f, s) returns all sets obtainable by choosing one element from f(x) for each element x of s. Elements of s are traversed in ascending order, and results appear in the lexicographic order of the choices, with the choice for the least element varying slowest.",+          "A result set may have fewer elements than s when distinct choices coincide. If f(x) is empty for any element, the result is the empty list; for the empty set the result is the single-element list containing the empty set.",+          "Requires 'ordering' constraints on both element types (the set type contract)."],+        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.TypeList (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.TypeList (Core.TypeSet (Core.TypeVariable (Core.Name "y"))))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+ maybeAt :: Packaging.PrimitiveDefinition maybeAt =     Packaging.PrimitiveDefinition {@@ -892,6 +1302,43 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +member :: Packaging.PrimitiveDefinition+member =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.member"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether an element is in a list."),+        Packaging.entityMetadataComments = [+          "member(x, xs) returns true iff some element of xs is equal to x.",+          "New name for elem (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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}+ nub :: Packaging.PrimitiveDefinition nub =     Packaging.PrimitiveDefinition {@@ -1189,6 +1636,48 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +sortBy :: Packaging.PrimitiveDefinition+sortBy =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.sortBy"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Sort a list using a key-extraction function."),+        Packaging.entityMetadataComments = [+          "sortBy(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.",+          "New name for sortOn (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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}+ sortOn :: Packaging.PrimitiveDefinition sortOn =     Packaging.PrimitiveDefinition {@@ -1324,6 +1813,36 @@               Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})),             Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})))} +tail :: Packaging.PrimitiveDefinition+tail =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.tail"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return all elements except the first, or Nothing if the list is empty."),+        Packaging.entityMetadataComments = [+          "tail(xs) returns Just(ys) where ys is xs with its first element removed, or Nothing if xs is empty.",+          "New name for maybeTail (retained as a deprecated alias until the #417 breaking wave removes it).",+          "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}+ take :: Packaging.PrimitiveDefinition take =     Packaging.PrimitiveDefinition {@@ -1357,6 +1876,55 @@       Packaging.primitiveDefinitionIsPure = True,       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing}++takeWhile :: Packaging.PrimitiveDefinition+takeWhile =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.takeWhile"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Take elements from the beginning of a list while a predicate holds."),+        Packaging.entityMetadataComments = [+          "takeWhile(p, xs) returns the longest prefix of xs whose elements all satisfy p. If p fails for the first element the result is the empty list; if p holds for every element the result is xs unchanged.",+          "dropWhile returns the complementary suffix, and span(p, xs) returns the pair of takeWhile(p, xs) and dropWhile(p, xs).",+          "Total. Corresponds to Haskell's takeWhile :: (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 = (Just (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "p"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "xs"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.span")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "p"))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))})))}  transpose :: Packaging.PrimitiveDefinition transpose =