hydra-kernel 0.17.0 → 0.17.1

raw patch · 89 files changed

+9977/−148 lines, 89 filesdep +SHAPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: SHA

API changes (from Hackage documentation)

Files

• CHANGELOG.md +139/−0
• hydra-kernel.cabal +40/−2
• src/main/haskell/Hydra/Codegen.hs +41/−1
• src/main/haskell/Hydra/Decode/Error/Packaging.hs +16/−1
• src/main/haskell/Hydra/Decode/Typed.hs +7/−0
• src/main/haskell/Hydra/Decoding.hs +8/−19
• src/main/haskell/Hydra/Dependencies.hs +3/−4
• src/main/haskell/Hydra/Dsl/Analysis.hs +307/−0
• src/main/haskell/Hydra/Dsl/Annotations.hs +324/−0
• src/main/haskell/Hydra/Dsl/Arity.hs +99/−0
• src/main/haskell/Hydra/Dsl/Ast.hs +58/−0
• src/main/haskell/Hydra/Dsl/Checking.hs +544/−0
• src/main/haskell/Hydra/Dsl/Coders.hs +128/−0
• src/main/haskell/Hydra/Dsl/Constants.hs +144/−0
• src/main/haskell/Hydra/Dsl/Core.hs +138/−0
• src/main/haskell/Hydra/Dsl/Dependencies.hs +203/−0
• src/main/haskell/Hydra/Dsl/Docs.hs +6/−0
• src/main/haskell/Hydra/Dsl/Environment.hs +193/−0
• src/main/haskell/Hydra/Dsl/Error/Checking.hs +63/−0
• src/main/haskell/Hydra/Dsl/Error/Core.hs +198/−0
• src/main/haskell/Hydra/Dsl/Error/File.hs +6/−0
• src/main/haskell/Hydra/Dsl/Error/Packaging.hs +189/−0
• src/main/haskell/Hydra/Dsl/Error/System.hs +6/−0
• src/main/haskell/Hydra/Dsl/Errors.hs +66/−0
• src/main/haskell/Hydra/Dsl/Extract/Json.hs +165/−0
• src/main/haskell/Hydra/Dsl/File.hs +18/−0
• src/main/haskell/Hydra/Dsl/Formatting.hs +205/−0
• src/main/haskell/Hydra/Dsl/Graph.hs +30/−0
• src/main/haskell/Hydra/Dsl/Json/Bootstrap.hs +37/−0
• src/main/haskell/Hydra/Dsl/Json/Decode.hs +153/−0
• src/main/haskell/Hydra/Dsl/Json/Decoding.hs +117/−0
• src/main/haskell/Hydra/Dsl/Json/Encode.hs +119/−0
• src/main/haskell/Hydra/Dsl/Json/Model.hs +6/−0
• src/main/haskell/Hydra/Dsl/Json/Parser.hs +143/−0
• src/main/haskell/Hydra/Dsl/Json/Writer.hs +105/−0
• src/main/haskell/Hydra/Dsl/Json/Yaml/Decode.hs +89/−0
• src/main/haskell/Hydra/Dsl/Json/Yaml/Encode.hs +89/−0
• src/main/haskell/Hydra/Dsl/Lexical.hs +299/−0
• src/main/haskell/Hydra/Dsl/Lib/Defaults.hs +26/−0
• src/main/haskell/Hydra/Dsl/Names.hs +229/−0
• src/main/haskell/Hydra/Dsl/Packaging.hs +74/−0
• src/main/haskell/Hydra/Dsl/Parsing.hs +62/−0
• src/main/haskell/Hydra/Dsl/Paths.hs +42/−0
• src/main/haskell/Hydra/Dsl/Predicates.hs +213/−0
• src/main/haskell/Hydra/Dsl/Query.hs +62/−0
• src/main/haskell/Hydra/Dsl/Reduction.hs +183/−0
• src/main/haskell/Hydra/Dsl/Refs.hs +138/−0
• src/main/haskell/Hydra/Dsl/Relational.hs +110/−0
• src/main/haskell/Hydra/Dsl/Resolution.hs +260/−0
• src/main/haskell/Hydra/Dsl/Rewriting.hs +261/−0
• src/main/haskell/Hydra/Dsl/Scoping.hs +130/−0
• src/main/haskell/Hydra/Dsl/Serialization.hs +512/−0
• src/main/haskell/Hydra/Dsl/Show/Docs.hs +127/−0
• src/main/haskell/Hydra/Dsl/Sorting.hs +165/−0
• src/main/haskell/Hydra/Dsl/Strip.hs +150/−0
• src/main/haskell/Hydra/Dsl/System.hs +18/−0
• src/main/haskell/Hydra/Dsl/Tabular.hs +52/−0
• src/main/haskell/Hydra/Dsl/Test/Transform.hs +170/−0
• src/main/haskell/Hydra/Dsl/Test/Utils.hs +95/−0
• src/main/haskell/Hydra/Dsl/Testing.hs +26/−0
• src/main/haskell/Hydra/Dsl/Time.hs +6/−0
• src/main/haskell/Hydra/Dsl/Topology.hs +26/−0
• src/main/haskell/Hydra/Dsl/Typing.hs +62/−0
• src/main/haskell/Hydra/Dsl/Util.hs +38/−0
• src/main/haskell/Hydra/Dsl/Validation.hs +26/−0
• src/main/haskell/Hydra/Dsl/Variables.hs +193/−0
• src/main/haskell/Hydra/Dsl/Variants.hs +14/−0
• src/main/haskell/Hydra/Dsl/Yaml/Model.hs +10/−0
• src/main/haskell/Hydra/Dsls.hs +226/−42
• src/main/haskell/Hydra/Encode/Error/Packaging.hs +21/−0
• src/main/haskell/Hydra/Encode/Typed.hs +7/−0
• src/main/haskell/Hydra/Encoding.hs +8/−19
• src/main/haskell/Hydra/Error/Packaging.hs +24/−1
• src/main/haskell/Hydra/Extract/Core.hs +0/−26
• src/main/haskell/Hydra/Extract/Json.hs +9/−8
• src/main/haskell/Hydra/Json/Decode.hs +22/−0
• src/main/haskell/Hydra/Json/Encode.hs +22/−0
• src/main/haskell/Hydra/Lib/Defaults.hs +1315/−0
• src/main/haskell/Hydra/Lib/Hashing.hs +88/−0
• src/main/haskell/Hydra/Lib/Lists.hs +24/−20
• src/main/haskell/Hydra/Names.hs +27/−0
• src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Testing.hs +13/−2
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Hashing.hs +16/−0
• src/main/haskell/Hydra/Overlay/Haskell/Libraries.hs +8/−0
• src/main/haskell/Hydra/Refs.hs +85/−0
• src/main/haskell/Hydra/Show/Error/Packaging.hs +14/−1
• src/main/haskell/Hydra/Typed.hs +8/−0
• src/main/haskell/Hydra/Validate/Core.hs +4/−2
• src/main/haskell/Hydra/Validate/Packaging.hs +55/−0

@@ -15,6 +15,145 @@  --- +## [0.17.1] - unreleased++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.++### New features++- **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).+- **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.++### API and usability++- **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.++### Fixed++Bug fixes landed this cycle, grouped by area (see each issue for detail):++- **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)),+  `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)).+- **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)).+- **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.++### 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.++---+ ## [0.17.0] - 2026-07-01  Major themes: first-class support for effects and I/O in the kernel, TypeScript and

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-kernel-version:        0.17.0+version:        0.17.1 synopsis:       The Hydra kernel: core types, terms, inference, and DSL runtime description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". This package is the Hydra kernel: the core type and term model, type inference, the term rewriting and reduction engine, the primitive library, and the DSL runtime — the code that must be present in every Hydra implementation. The convenient entry point is the Hydra.Kernel module, which re-exports the kernel's collision-free surface. category:       Data@@ -70,20 +70,39 @@       Hydra.Dependencies       Hydra.Differentiation       Hydra.Docs+      Hydra.Dsl.Analysis+      Hydra.Dsl.Annotations+      Hydra.Dsl.Arity       Hydra.Dsl.Ast+      Hydra.Dsl.Checking       Hydra.Dsl.Coders+      Hydra.Dsl.Constants       Hydra.Dsl.Core+      Hydra.Dsl.Dependencies       Hydra.Dsl.Docs+      Hydra.Dsl.Environment       Hydra.Dsl.Error.Checking       Hydra.Dsl.Error.Core       Hydra.Dsl.Error.File       Hydra.Dsl.Error.Packaging       Hydra.Dsl.Error.System       Hydra.Dsl.Errors+      Hydra.Dsl.Extract.Json       Hydra.Dsl.File+      Hydra.Dsl.Formatting       Hydra.Dsl.Graph+      Hydra.Dsl.Json.Bootstrap+      Hydra.Dsl.Json.Decode+      Hydra.Dsl.Json.Decoding+      Hydra.Dsl.Json.Encode       Hydra.Dsl.Json.Model+      Hydra.Dsl.Json.Parser+      Hydra.Dsl.Json.Writer+      Hydra.Dsl.Json.Yaml.Decode+      Hydra.Dsl.Json.Yaml.Encode+      Hydra.Dsl.Lexical       Hydra.Dsl.Lib.Chars+      Hydra.Dsl.Lib.Defaults       Hydra.Dsl.Lib.Eithers       Hydra.Dsl.Lib.Equality       Hydra.Dsl.Lib.Lists@@ -96,19 +115,33 @@       Hydra.Dsl.Lib.Regex       Hydra.Dsl.Lib.Sets       Hydra.Dsl.Lib.Strings+      Hydra.Dsl.Names       Hydra.Dsl.Packaging       Hydra.Dsl.Parsing       Hydra.Dsl.Paths+      Hydra.Dsl.Predicates       Hydra.Dsl.Query+      Hydra.Dsl.Reduction+      Hydra.Dsl.Refs       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       Hydra.Dsl.Tabular+      Hydra.Dsl.Test.Transform+      Hydra.Dsl.Test.Utils       Hydra.Dsl.Testing       Hydra.Dsl.Time       Hydra.Dsl.Topology       Hydra.Dsl.Typing       Hydra.Dsl.Util       Hydra.Dsl.Validation+      Hydra.Dsl.Variables       Hydra.Dsl.Variants       Hydra.Dsl.Yaml.Model       Hydra.Dsls@@ -169,10 +202,12 @@       Hydra.Languages       Hydra.Lexical       Hydra.Lib.Chars+      Hydra.Lib.Defaults       Hydra.Lib.Effects       Hydra.Lib.Eithers       Hydra.Lib.Equality       Hydra.Lib.Files+      Hydra.Lib.Hashing       Hydra.Lib.Lists       Hydra.Lib.Literals       Hydra.Lib.Logic@@ -215,6 +250,7 @@       Hydra.Overlay.Haskell.Lib.Eithers       Hydra.Overlay.Haskell.Lib.Equality       Hydra.Overlay.Haskell.Lib.Files+      Hydra.Overlay.Haskell.Lib.Hashing       Hydra.Overlay.Haskell.Lib.Lists       Hydra.Overlay.Haskell.Lib.Literals       Hydra.Overlay.Haskell.Lib.Logic@@ -237,6 +273,7 @@       Hydra.Read.Docs       Hydra.Reduction       Hydra.Reflect+      Hydra.Refs       Hydra.Relational       Hydra.Resolution       Hydra.Rewriting@@ -279,7 +316,8 @@   hs-source-dirs:       src/main/haskell   build-depends:-      base >=4.19.0 && <4.22+      SHA >=1.6.4 && <1.7+    , base >=4.19.0 && <4.22     , base64-bytestring >=1.2.1 && <1.3     , bytestring >=0.11.5 && <0.13     , containers >=0.6.7 && <0.8

@@ -304,7 +304,47 @@                     _ -> Nothing) (Packaging.moduleDefinitions m))) kernelModules)       in (Eithers.bind (Inference.inferGraphTypes cx dataElements g0) (\inferResultWithCx ->         let g1 = Pairs.first (Pairs.first inferResultWithCx)-        in (generateLexicon g1)))+            schemaElements =+                    Lists.concat (Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of+                      Packaging.DefinitionType v0 -> Just ((\name -> \typ ->+                        let schemaTerm = Core.TermVariable (Core.Name "hydra.core.Type")+                            dataTerm =+                                    Annotations.normalizeTermAnnotations (Core.TermAnnotated (Core.AnnotatedTerm {+                                      Core.annotatedTermBody = (EncodeCore.type_ typ),+                                      Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.fromList [+                                        (Constants.keyType, schemaTerm)]))}))+                        in Core.Binding {+                          Core.bindingName = name,+                          Core.bindingTerm = dataTerm,+                          Core.bindingTypeScheme = (Just (Core.TypeScheme {+                            Core.typeSchemeVariables = [],+                            Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                            Core.typeSchemeConstraints = Nothing}))}) (Packaging.typeDefinitionName v0) (Core.typeSchemeBody (Packaging.typeDefinitionBody v0)))+                      _ -> Nothing) (Packaging.moduleDefinitions m))) kernelModules)+            typeBoundTerms = Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) schemaElements)+            typeBoundTypes =+                    Maps.fromList (Optionals.cat (Lists.map (\b -> Optionals.map (\ts -> (Core.bindingName b, ts)) (Core.bindingTypeScheme b)) schemaElements))+            g2 =+                    Graph.Graph {+                      Graph.graphBoundTerms = (Maps.union typeBoundTerms (Graph.graphBoundTerms g1)),+                      Graph.graphBoundTypes = (Graph.graphBoundTypes g1),+                      Graph.graphClassConstraints = (Graph.graphClassConstraints g1),+                      Graph.graphLambdaVariables = (Graph.graphLambdaVariables g1),+                      Graph.graphMetadata = (Graph.graphMetadata g1),+                      Graph.graphPrimitives = (Graph.graphPrimitives g1),+                      Graph.graphSchemaTypes = (Graph.graphSchemaTypes g1),+                      Graph.graphTypeVariables = (Graph.graphTypeVariables g1)}+            g3 =+                    Graph.Graph {+                      Graph.graphBoundTerms = (Graph.graphBoundTerms g2),+                      Graph.graphBoundTypes = (Maps.union typeBoundTypes (Graph.graphBoundTypes g2)),+                      Graph.graphClassConstraints = (Graph.graphClassConstraints g2),+                      Graph.graphLambdaVariables = (Graph.graphLambdaVariables g2),+                      Graph.graphMetadata = (Graph.graphMetadata g2),+                      Graph.graphPrimitives = (Graph.graphPrimitives g2),+                      Graph.graphSchemaTypes = (Graph.graphSchemaTypes g2),+                      Graph.graphTypeVariables = (Graph.graphTypeVariables g2)}+        in (generateLexicon g3)))  -- | Perform type inference on modules and reconstruct with inferred types inferModules :: Typing.InferenceContext -> Graph.Graph -> [Packaging.Module] -> [Packaging.Module] -> Either Errors.Error [Packaging.Module]

@@ -170,7 +170,10 @@                         (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidModule t) (invalidModuleError cx input))),                       (                         Core.Name "invalidPackageName",-                        (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidPackageName t) (invalidPackageNameError cx input)))]+                        (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidPackageName t) (invalidPackageNameError cx input))),+                      (+                        Core.Name "undeclaredDependency",+                        (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorUndeclaredDependency t) (undeclaredDependencyError cx input)))]         in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.cat [           "no such field ",           (Core.unName fname),@@ -197,3 +200,15 @@           ErrorPackaging.missingDocumentationErrorModuleName = field_moduleName,           ErrorPackaging.missingDocumentationErrorName = field_name}))))       _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.MissingDocumentationError")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.UndeclaredDependencyError+undeclaredDependencyError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "referencedName" DecodeCore.name fieldMap cx) (\field_referencedName -> Eithers.bind (ExtractCore.requireField "owningModuleName" DecodePackaging.moduleName fieldMap cx) (\field_owningModuleName -> Right (ErrorPackaging.UndeclaredDependencyError {+          ErrorPackaging.undeclaredDependencyErrorModuleName = field_moduleName,+          ErrorPackaging.undeclaredDependencyErrorReferencedName = field_referencedName,+          ErrorPackaging.undeclaredDependencyErrorOwningModuleName = field_owningModuleName})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.UndeclaredDependencyError")) (ExtractCore.stripWithDecodingError cx raw)

@@ -28,6 +28,13 @@           Typed.typedBindingTerm = field_term}))))       _ -> Left (Errors.DecodingError "expected a record of type hydra.typed.TypedBinding")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.typed.TypedName+typedName :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedName a)+typedName a cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Typed.TypedName b) (DecodeCore.name cx (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+ -- | Decoder for hydra.typed.TypedTerm typedTerm :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedTerm a) typedTerm a cx raw =

@@ -29,7 +29,6 @@ import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals-import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Names as Names import qualified Hydra.Packaging as Packaging@@ -126,17 +125,10 @@  -- | Generate a binding name for a decoder function from a type name decodeBindingName :: Core.Name -> Core.Name-decodeBindingName n =--      let parts = Strings.splitOn "." (Core.unName n)-          localPart = Formatting.decapitalize (Names.localNameOf n)-          localResult = Core.Name localPart-      in (Optionals.cases (Lists.maybeInit parts) localResult (\nsParts -> Optionals.cases (Lists.uncons nsParts) localResult (\nsUc ->-        let tail = Pairs.second nsUc-        in (Core.Name (Strings.intercalate "." (Lists.concat2 [-          "hydra",-          "decode"] (Lists.concat2 tail [-          localPart])))))))+decodeBindingName =+    Names.derivedBindingName [+      "hydra",+      "decode"] True  -- | Generate a decoder for an Either type decodeEitherType :: Core.EitherType -> Core.Term@@ -1552,13 +1544,10 @@  -- | Generate a decoder module name from a source module name decodeModuleName :: Packaging.ModuleName -> Packaging.ModuleName-decodeModuleName ns =--      let parts = Strings.splitOn "." (Packaging.unModuleName ns)-          fallback = Packaging.ModuleName (Packaging.unModuleName ns)-      in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.cat [-        "hydra.decode.",-        (Strings.intercalate "." (Pairs.second uc))])))+decodeModuleName =+    Names.derivedModuleName [+      "hydra",+      "decode"] True  -- | Generate a decoder for a pair type decodePairType :: Core.PairType -> Core.Term

@@ -4,8 +4,10 @@  module Hydra.Dependencies where +import qualified Hydra.Annotations as Annotations import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants import qualified Hydra.Core as Core import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking@@ -311,10 +313,7 @@        let bindings = Maps.toList bindingMap           keys = Sets.fromList (Lists.map Pairs.first bindings)-          hasTypeAnnotation =-                  \term -> case term of-                    Core.TermAnnotated v0 -> hasTypeAnnotation (Core.annotatedTermBody v0)-                    _ -> False+          hasTypeAnnotation = \term -> Optionals.isGiven (Annotations.getTermAnnotation Constants.keyType term)           depsOf =                   \nameAndTerm ->                     let name = Pairs.first nameAndTerm

@@ -0,0 +1,307 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.analysis++module Hydra.Dsl.Analysis where++import qualified Hydra.Analysis as Analysis+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Arity as Arity+import qualified Hydra.Ast as Ast+import qualified Hydra.Checking as Checking+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Dependencies as Dependencies+import qualified Hydra.Docs as Docs+import qualified Hydra.Dsl.Annotations as DslAnnotations+import qualified Hydra.Dsl.Arity as DslArity+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Checking as DslChecking+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Constants as DslConstants+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Dependencies as DslDependencies+import qualified Hydra.Dsl.Docs as DslDocs+import qualified Hydra.Dsl.Error.Checking as DslErrorChecking+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.Lexical as DslLexical+import qualified Hydra.Dsl.Names as DslNames+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.Predicates as DslPredicates+import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Relational as DslRelational+import qualified Hydra.Dsl.Rewriting as DslRewriting+import qualified Hydra.Dsl.Scoping as DslScoping+import qualified Hydra.Dsl.Strip as DslStrip+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.Variables as DslVariables+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as ErrorChecking+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.Lexical as Lexical+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Predicates as Predicates+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Strip as Strip+import qualified Hydra.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.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S++-- | DSL reference to hydra.analysis.addNamesToModuleNames+addNamesToModuleNames :: Typed.TypedTerm (Packaging.ModuleName -> t0) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (Util.ModuleNames t0) -> Typed.TypedTerm (Util.ModuleNames t0)+addNamesToModuleNames 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.analysis.addNamesToModuleNames")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.analysis.analyzeFunctionTerm+analyzeFunctionTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t0) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 (Typing.FunctionStructure t0))+analyzeFunctionTerm arg0 arg1 arg2 arg3 arg4 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.analyzeFunctionTerm")),+              Core.applicationArgument = (Typed.unTypedTerm arg0)})),+            Core.applicationArgument = (Typed.unTypedTerm arg1)})),+          Core.applicationArgument = (Typed.unTypedTerm arg2)})),+        Core.applicationArgument = (Typed.unTypedTerm arg3)})),+      Core.applicationArgument = (Typed.unTypedTerm arg4)}))++-- | DSL reference to hydra.analysis.analyzeFunctionTermWith+analyzeFunctionTermWith :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t0) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 (Typing.FunctionStructure t0))+analyzeFunctionTermWith arg0 arg1 arg2 arg3 arg4 arg5 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.analyzeFunctionTermWith")),+                Core.applicationArgument = (Typed.unTypedTerm arg0)})),+              Core.applicationArgument = (Typed.unTypedTerm arg1)})),+            Core.applicationArgument = (Typed.unTypedTerm arg2)})),+          Core.applicationArgument = (Typed.unTypedTerm arg3)})),+        Core.applicationArgument = (Typed.unTypedTerm arg4)})),+      Core.applicationArgument = (Typed.unTypedTerm arg5)}))++-- | DSL reference to hydra.analysis.analyzeFunctionTermWithFinish+analyzeFunctionTermWithFinish :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm t0 -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 (Typing.FunctionStructure t0))+analyzeFunctionTermWithFinish arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.analyzeFunctionTermWithFinish")),+                      Core.applicationArgument = (Typed.unTypedTerm arg0)})),+                    Core.applicationArgument = (Typed.unTypedTerm arg1)})),+                  Core.applicationArgument = (Typed.unTypedTerm arg2)})),+                Core.applicationArgument = (Typed.unTypedTerm arg3)})),+              Core.applicationArgument = (Typed.unTypedTerm arg4)})),+            Core.applicationArgument = (Typed.unTypedTerm arg5)})),+          Core.applicationArgument = (Typed.unTypedTerm arg6)})),+        Core.applicationArgument = (Typed.unTypedTerm arg7)})),+      Core.applicationArgument = (Typed.unTypedTerm arg8)}))++-- | DSL reference to hydra.analysis.analyzeFunctionTermWithGather+analyzeFunctionTermWithGather :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t0) -> Typed.TypedTerm Bool -> Typed.TypedTerm t0 -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 (Typing.FunctionStructure t0))+analyzeFunctionTermWithGather arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.analyzeFunctionTermWithGather")),+                            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+                          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+                        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+                      Core.applicationArgument = (Typed.unTypedTerm arg3)})),+                    Core.applicationArgument = (Typed.unTypedTerm arg4)})),+                  Core.applicationArgument = (Typed.unTypedTerm arg5)})),+                Core.applicationArgument = (Typed.unTypedTerm arg6)})),+              Core.applicationArgument = (Typed.unTypedTerm arg7)})),+            Core.applicationArgument = (Typed.unTypedTerm arg8)})),+          Core.applicationArgument = (Typed.unTypedTerm arg9)})),+        Core.applicationArgument = (Typed.unTypedTerm arg10)})),+      Core.applicationArgument = (Typed.unTypedTerm arg11)}))++-- | DSL reference to hydra.analysis.definitionDependencyModuleNames+definitionDependencyModuleNames :: Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm (S.Set Packaging.ModuleName)+definitionDependencyModuleNames arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.definitionDependencyModuleNames")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.analysis.dependencyModuleNames+dependencyModuleNames :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Either Errors.Error (S.Set Packaging.ModuleName))+dependencyModuleNames arg0 arg1 arg2 arg3 arg4 arg5 arg6 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.dependencyModuleNames")),+                  Core.applicationArgument = (Typed.unTypedTerm arg0)})),+                Core.applicationArgument = (Typed.unTypedTerm arg1)})),+              Core.applicationArgument = (Typed.unTypedTerm arg2)})),+            Core.applicationArgument = (Typed.unTypedTerm arg3)})),+          Core.applicationArgument = (Typed.unTypedTerm arg4)})),+        Core.applicationArgument = (Typed.unTypedTerm arg5)})),+      Core.applicationArgument = (Typed.unTypedTerm arg6)}))++-- | DSL reference to hydra.analysis.gatherApplications+gatherApplications :: Typed.TypedTerm Core.Term -> Typed.TypedTerm ([Core.Term], Core.Term)+gatherApplications arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.gatherApplications")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.analysis.gatherArgs+gatherArgs :: Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Term] -> Typed.TypedTerm (Core.Term, [Core.Term])+gatherArgs arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.gatherArgs")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.analysis.gatherArgsWithTypeApps+gatherArgsWithTypeApps :: Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Term] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Core.Term, ([Core.Term], [Core.Type]))+gatherArgsWithTypeApps 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.analysis.gatherArgsWithTypeApps")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.analysis.isSelfTailRecursive+isSelfTailRecursive :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isSelfTailRecursive arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.isSelfTailRecursive")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.analysis.isSimpleAssignment+isSimpleAssignment :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isSimpleAssignment arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.isSimpleAssignment")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.analysis.isTailRecursiveInTailPosition+isTailRecursiveInTailPosition :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isTailRecursiveInTailPosition arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.isTailRecursiveInTailPosition")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.analysis.moduleContainsBinaryLiterals+moduleContainsBinaryLiterals :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Bool+moduleContainsBinaryLiterals arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.moduleContainsBinaryLiterals")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.analysis.moduleContainsDecimalLiterals+moduleContainsDecimalLiterals :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Bool+moduleContainsDecimalLiterals arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.moduleContainsDecimalLiterals")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.analysis.moduleDependencyModuleNames+moduleDependencyModuleNames :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Packaging.Module -> Typed.TypedTerm (Either Errors.Error (S.Set Packaging.ModuleName))+moduleDependencyModuleNames arg0 arg1 arg2 arg3 arg4 arg5 arg6 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.moduleDependencyModuleNames")),+                  Core.applicationArgument = (Typed.unTypedTerm arg0)})),+                Core.applicationArgument = (Typed.unTypedTerm arg1)})),+              Core.applicationArgument = (Typed.unTypedTerm arg2)})),+            Core.applicationArgument = (Typed.unTypedTerm arg3)})),+          Core.applicationArgument = (Typed.unTypedTerm arg4)})),+        Core.applicationArgument = (Typed.unTypedTerm arg5)})),+      Core.applicationArgument = (Typed.unTypedTerm arg6)}))++-- | DSL reference to hydra.analysis.moduleNamesForDefinitions+moduleNamesForDefinitions :: Typed.TypedTerm (Packaging.ModuleName -> t0) -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm (Util.ModuleNames t0)+moduleNamesForDefinitions 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.analysis.moduleNamesForDefinitions")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))

@@ -0,0 +1,324 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.annotations++module Hydra.Dsl.Annotations where++import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Docs as Docs+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Constants as DslConstants+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.Lexical as DslLexical+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.Strip as DslStrip+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.Encode.Core as EncodeCore+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.Extract.Core as ExtractCore+import qualified Hydra.File as File+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Strip as Strip+import qualified Hydra.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+import qualified Data.Map as M+import qualified Data.Set as S++-- | DSL reference to hydra.annotations.aggregateAnnotations+aggregateAnnotations :: Ord t2 => (Typed.TypedTerm (t0 -> Maybe t1) -> Typed.TypedTerm (t1 -> t0) -> Typed.TypedTerm (t1 -> M.Map t2 t3) -> Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map t2 t3))+aggregateAnnotations 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.annotations.aggregateAnnotations")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.annotations.commentsFromBinding+commentsFromBinding :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm (Either Errors.Error (Maybe String))+commentsFromBinding 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.annotations.commentsFromBinding")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.commentsFromFieldType+commentsFromFieldType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.FieldType -> Typed.TypedTerm (Either Errors.Error (Maybe String))+commentsFromFieldType 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.annotations.commentsFromFieldType")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.getAnnotationMap+getAnnotationMap :: Typed.TypedTerm Core.Term -> Typed.TypedTerm (M.Map Core.Name Core.Term)+getAnnotationMap arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.getAnnotationMap")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.annotations.getDescription+getDescription :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (Either Errors.Error (Maybe String))+getDescription 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.annotations.getDescription")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.getTermAnnotation+getTermAnnotation :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Maybe Core.Term)+getTermAnnotation arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.getTermAnnotation")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.annotations.getTermDescription+getTermDescription :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error (Maybe String))+getTermDescription 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.annotations.getTermDescription")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.getType+getType :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (Either Errors.DecodingError (Maybe Core.Type))+getType arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.getType")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.annotations.getTypeAnnotation+getTypeAnnotation :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Maybe Core.Term)+getTypeAnnotation arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.getTypeAnnotation")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.annotations.getTypeClasses+getTypeClasses :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error (M.Map Core.Name (S.Set Core.Name)))+getTypeClasses 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.annotations.getTypeClasses")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.getTypeDescription+getTypeDescription :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error (Maybe String))+getTypeDescription 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.annotations.getTypeDescription")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.hasDescription+hasDescription :: Typed.TypedTerm (M.Map Core.Name t0) -> Typed.TypedTerm Bool+hasDescription arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.hasDescription")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.annotations.hasTypeDescription+hasTypeDescription :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool+hasTypeDescription arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.hasTypeDescription")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.annotations.isNativeType+isNativeType :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Bool+isNativeType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.isNativeType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.annotations.normalizeTermAnnotations+normalizeTermAnnotations :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+normalizeTermAnnotations arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.normalizeTermAnnotations")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.annotations.normalizeTypeAnnotations+normalizeTypeAnnotations :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+normalizeTypeAnnotations arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.normalizeTypeAnnotations")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.annotations.setAnnotation+setAnnotation :: Ord t0 => (Typed.TypedTerm t0 -> Typed.TypedTerm (Maybe t1) -> Typed.TypedTerm (M.Map t0 t1) -> Typed.TypedTerm (M.Map t0 t1))+setAnnotation 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.annotations.setAnnotation")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.setDescription+setDescription :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Core.Term)+setDescription arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setDescription")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.annotations.setTermAnnotation+setTermAnnotation :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+setTermAnnotation 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.annotations.setTermAnnotation")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.setTermDescription+setTermDescription :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+setTermDescription arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setTermDescription")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.annotations.setType+setType :: Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Core.Term)+setType arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setType")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.annotations.setTypeAnnotation+setTypeAnnotation :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+setTypeAnnotation 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.annotations.setTypeAnnotation")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.annotations.setTypeClasses+setTypeClasses :: Typed.TypedTerm (M.Map Core.Name (S.Set Core.Name)) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+setTypeClasses arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setTypeClasses")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.annotations.setTypeDescription+setTypeDescription :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+setTypeDescription arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setTypeDescription")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.annotations.termAnnotationInternal+termAnnotationInternal :: Typed.TypedTerm Core.Term -> Typed.TypedTerm (M.Map Core.Name Core.Term)+termAnnotationInternal arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.termAnnotationInternal")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.annotations.typeAnnotationInternal+typeAnnotationInternal :: Typed.TypedTerm Core.Type -> Typed.TypedTerm (M.Map Core.Name Core.Term)+typeAnnotationInternal arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.typeAnnotationInternal")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.annotations.wrapAnnotationMap+wrapAnnotationMap :: Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm Core.Term+wrapAnnotationMap arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.wrapAnnotationMap")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -0,0 +1,99 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.arity++module Hydra.Dsl.Arity where++import qualified Hydra.Arity as Arity+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.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.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.arity.primitiveArity+primitiveArity :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm Int+primitiveArity arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.primitiveArity")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.arity.termArity+termArity :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Int+termArity arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.termArity")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.arity.typeArity+typeArity :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Int+typeArity arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.typeArity")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.arity.typeSchemeArity+typeSchemeArity :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Int+typeSchemeArity arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.typeSchemeArity")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.arity.uncurryType+uncurryType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Core.Type]+uncurryType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.uncurryType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -6,11 +6,17 @@  import qualified Hydra.Ast as Ast import qualified Hydra.Core as Core+import qualified Hydra.Decode.Ast as DecodeAst import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Encode.Ast as EncodeAst import qualified Hydra.Typed as Typed import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL name token for hydra.ast.Associativity+associativityAssociativity :: Typed.TypedName Ast.Associativity+associativityAssociativity = Typed.TypedName (Core.Name "hydra.ast.Associativity")+ -- | DSL injection for the both variant of hydra.ast.Associativity associativityBoth :: Typed.TypedTerm Ast.Associativity associativityBoth =@@ -63,6 +69,10 @@           Core.fieldName = (Core.Name "newlineAfterContent"),           Core.fieldTerm = (Typed.unTypedTerm newlineAfterContent)}]})) +-- | DSL name token for hydra.ast.BlockStyle+blockStyleBlockStyle :: Typed.TypedName Ast.BlockStyle+blockStyleBlockStyle = Typed.TypedName (Core.Name "hydra.ast.BlockStyle")+ -- | DSL accessor for the indent field of hydra.ast.BlockStyle blockStyleIndent :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm (Maybe String) blockStyleIndent x =@@ -178,6 +188,10 @@           Core.fieldName = (Core.Name "style"),           Core.fieldTerm = (Typed.unTypedTerm style)}]})) +-- | DSL name token for hydra.ast.BracketExpr+bracketExprBracketExpr :: Typed.TypedName Ast.BracketExpr+bracketExprBracketExpr = Typed.TypedName (Core.Name "hydra.ast.BracketExpr")+ -- | DSL accessor for the brackets field of hydra.ast.BracketExpr bracketExprBrackets :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.Brackets bracketExprBrackets x =@@ -290,6 +304,10 @@           Core.fieldName = (Core.Name "close"),           Core.fieldTerm = (Typed.unTypedTerm close)}]})) +-- | DSL name token for hydra.ast.Brackets+bracketsBrackets :: Typed.TypedName Ast.Brackets+bracketsBrackets = Typed.TypedName (Core.Name "hydra.ast.Brackets")+ -- | DSL accessor for the close field of hydra.ast.Brackets bracketsClose :: Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.Symbol bracketsClose x =@@ -360,6 +378,10 @@         Core.fieldName = (Core.Name "const"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.ast.Expr+exprExpr :: Typed.TypedName Ast.Expr+exprExpr = Typed.TypedName (Core.Name "hydra.ast.Expr")+ -- | DSL injection for the indent variant of hydra.ast.Expr exprIndent :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.Expr exprIndent x =@@ -396,6 +418,10 @@         Core.fieldName = (Core.Name "allLines"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.ast.IndentStyle+indentStyleIndentStyle :: Typed.TypedName Ast.IndentStyle+indentStyleIndentStyle = Typed.TypedName (Core.Name "hydra.ast.IndentStyle")+ -- | DSL injection for the subsequentLines variant of hydra.ast.IndentStyle indentStyleSubsequentLines :: Typed.TypedTerm String -> Typed.TypedTerm Ast.IndentStyle indentStyleSubsequentLines x =@@ -427,6 +453,10 @@         Core.projectionFieldName = (Core.Name "expr")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.IndentedExpression+indentedExpressionIndentedExpression :: Typed.TypedName Ast.IndentedExpression+indentedExpressionIndentedExpression = Typed.TypedName (Core.Name "hydra.ast.IndentedExpression")+ -- | DSL accessor for the style field of hydra.ast.IndentedExpression indentedExpressionStyle :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.IndentStyle indentedExpressionStyle x =@@ -532,6 +562,10 @@         Core.projectionFieldName = (Core.Name "op")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.OpExpr+opExprOpExpr :: Typed.TypedName Ast.OpExpr+opExprOpExpr = Typed.TypedName (Core.Name "hydra.ast.OpExpr")+ -- | DSL accessor for the rhs field of hydra.ast.OpExpr opExprRhs :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Expr opExprRhs x =@@ -613,6 +647,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.ast.Op+opOp :: Typed.TypedName Ast.Op+opOp = Typed.TypedName (Core.Name "hydra.ast.Op")+ -- | DSL accessor for the padding field of hydra.ast.Op opPadding :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Padding opPadding x =@@ -786,6 +824,10 @@         Core.projectionFieldName = (Core.Name "left")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.Padding+paddingPadding :: Typed.TypedName Ast.Padding+paddingPadding = Typed.TypedName (Core.Name "hydra.ast.Padding")+ -- | DSL accessor for the right field of hydra.ast.Padding paddingRight :: Typed.TypedTerm Ast.Padding -> Typed.TypedTerm Ast.Ws paddingRight x =@@ -836,6 +878,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.Precedence+precedencePrecedence :: Typed.TypedName Ast.Precedence+precedencePrecedence = Typed.TypedName (Core.Name "hydra.ast.Precedence")+ -- | DSL constructor for hydra.ast.SeqExpr seqExpr :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.SeqExpr seqExpr op elements =@@ -867,6 +913,10 @@         Core.projectionFieldName = (Core.Name "op")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.SeqExpr+seqExprSeqExpr :: Typed.TypedName Ast.SeqExpr+seqExprSeqExpr = Typed.TypedName (Core.Name "hydra.ast.SeqExpr")+ -- | DSL updater for the elements field of hydra.ast.SeqExpr seqExprWithElements :: Typed.TypedTerm Ast.SeqExpr -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.SeqExpr seqExprWithElements original newVal =@@ -908,6 +958,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.Symbol+symbolSymbol :: Typed.TypedName Ast.Symbol+symbolSymbol = Typed.TypedName (Core.Name "hydra.ast.Symbol")+ -- | DSL accessor for the body of hydra.ast.Precedence unPrecedence :: Typed.TypedTerm Ast.Precedence -> Typed.TypedTerm Int unPrecedence x =@@ -966,3 +1020,7 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "space"),         Core.fieldTerm = Core.TermUnit}}))++-- | DSL name token for hydra.ast.Ws+wsWs :: Typed.TypedName Ast.Ws+wsWs = Typed.TypedName (Core.Name "hydra.ast.Ws")

@@ -0,0 +1,544 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.checking++module Hydra.Dsl.Checking where++import qualified Hydra.Ast as Ast+import qualified Hydra.Checking as Checking+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Dependencies as Dependencies+import qualified Hydra.Docs as Docs+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Constants as DslConstants+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Dependencies as DslDependencies+import qualified Hydra.Dsl.Docs as DslDocs+import qualified Hydra.Dsl.Error.Checking as DslErrorChecking+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.Formatting as DslFormatting+import qualified Hydra.Dsl.Graph as DslGraph+import qualified Hydra.Dsl.Json.Model as JsonModel+import qualified Hydra.Dsl.Lexical as DslLexical+import qualified Hydra.Dsl.Names as DslNames+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.Resolution as DslResolution+import qualified Hydra.Dsl.Rewriting as DslRewriting+import qualified Hydra.Dsl.Scoping as DslScoping+import qualified Hydra.Dsl.Strip as DslStrip+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.Variables as DslVariables+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as ErrorChecking+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.Extract.Core as ExtractCore+import qualified Hydra.File as File+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Reflect as Reflect+import qualified Hydra.Relational as Relational+import qualified Hydra.Resolution as Resolution+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Show.Variants as ShowVariants+import qualified Hydra.Strip as Strip+import qualified Hydra.Substitution as Substitution+import qualified Hydra.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.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S++-- | DSL reference to hydra.checking.allEqual+allEqual :: Typed.TypedTerm [t0] -> Typed.TypedTerm Bool+allEqual arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.allEqual")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.checking.applyTypeArgumentsToType+applyTypeArgumentsToType :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error Core.Type)+applyTypeArgumentsToType 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.applyTypeArgumentsToType")),+            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.checkForUnboundTypeVariables+checkForUnboundTypeVariables :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error ())+checkForUnboundTypeVariables 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.checking.checkForUnboundTypeVariables")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        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 =+    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.checkSameType")),+            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.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 =+    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.checking.checkTypeSubst")),+          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+containsInScopeTypeVars arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.containsInScopeTypeVars")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.checking.normalizeTypeFreeVars+normalizeTypeFreeVars :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+normalizeTypeFreeVars arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.normalizeTypeFreeVars")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.checking.toFContext+toFContext :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Type)+toFContext arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.toFContext")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.checking.typeListsEffectivelyEqual+typeListsEffectivelyEqual :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Bool+typeListsEffectivelyEqual 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.checking.typeListsEffectivelyEqual")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.checking.typeOf+typeOf :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOf 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.typeOf")),+            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.typeOfAnnotatedTerm+typeOfAnnotatedTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfAnnotatedTerm 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.typeOfAnnotatedTerm")),+            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.typeOfApplication+typeOfApplication :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Application -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfApplication 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.typeOfApplication")),+            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.typeOfCaseStatement+typeOfCaseStatement :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfCaseStatement 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.typeOfCaseStatement")),+            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.typeOfEither+typeOfEither :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Either Core.Term Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfEither 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.typeOfEither")),+            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.typeOfInjection+typeOfInjection :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Injection -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfInjection 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.typeOfInjection")),+            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.typeOfLambda+typeOfLambda :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Lambda -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfLambda 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.typeOfLambda")),+            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.typeOfLet+typeOfLet :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Let -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfLet 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.typeOfLet")),+            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.typeOfList+typeOfList :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm [Core.Term] -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfList 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.typeOfList")),+            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.typeOfLiteral+typeOfLiteral :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Literal -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfLiteral 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.typeOfLiteral")),+            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.typeOfMap+typeOfMap :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (M.Map Core.Term Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfMap 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.typeOfMap")),+            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.typeOfMaybe+typeOfMaybe :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfMaybe 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.typeOfMaybe")),+            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.typeOfPair+typeOfPair :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Core.Term, Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfPair 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.typeOfPair")),+            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.typeOfPrimitive+typeOfPrimitive :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfPrimitive 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.typeOfPrimitive")),+            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.typeOfProjection+typeOfProjection :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Projection -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfProjection 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.typeOfProjection")),+            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.typeOfRecord+typeOfRecord :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Record -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfRecord 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.typeOfRecord")),+            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.typeOfSet+typeOfSet :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (S.Set Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfSet 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.typeOfSet")),+            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.typeOfTerm+typeOfTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error Core.Type)+typeOfTerm 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.checking.typeOfTerm")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.checking.typeOfTypeApplication+typeOfTypeApplication :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfTypeApplication 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.typeOfTypeApplication")),+            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.typeOfTypeLambda+typeOfTypeLambda :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfTypeLambda 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.typeOfTypeLambda")),+            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.typeOfUnit+typeOfUnit :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfUnit 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.checking.typeOfUnit")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.checking.typeOfUnwrap+typeOfUnwrap :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfUnwrap 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.typeOfUnwrap")),+            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.typeOfVariable+typeOfVariable :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfVariable 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.typeOfVariable")),+            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.typeOfWrappedTerm+typeOfWrappedTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.WrappedTerm -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext))+typeOfWrappedTerm 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.typeOfWrappedTerm")),+            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.typesAllEffectivelyEqual+typesAllEffectivelyEqual :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Bool+typesAllEffectivelyEqual arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.typesAllEffectivelyEqual")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.checking.typesEffectivelyEqual+typesEffectivelyEqual :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool+typesEffectivelyEqual 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.checking.typesEffectivelyEqual")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))

@@ -6,12 +6,14 @@  import qualified Hydra.Coders as Coders import qualified Hydra.Core as Core+import qualified Hydra.Decode.Coders as DecodeCoders import qualified Hydra.Dsl.Core as DslCore 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.Util as DslUtil import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Encode.Coders as EncodeCoders import qualified Hydra.Errors as Errors import qualified Hydra.File as File import qualified Hydra.Graph as Graph@@ -42,6 +44,10 @@           Core.fieldName = (Core.Name "coder"),           Core.fieldTerm = (Typed.unTypedTerm coder)}]})) +-- | DSL name token for hydra.coders.Adapter+adapterAdapter :: Typed.TypedName (Coders.Adapter t1 t2 v1 v2 e)+adapterAdapter = Typed.TypedName (Core.Name "hydra.coders.Adapter")+ -- | DSL accessor for the coder field of hydra.coders.Adapter adapterCoder :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2 e) -> Typed.TypedTerm (Coders.Coder v1 v2 e) adapterCoder x =@@ -67,6 +73,10 @@           Core.fieldName = (Core.Name "adapters"),           Core.fieldTerm = (Typed.unTypedTerm adapters)}]})) +-- | DSL name token for hydra.coders.AdapterContext+adapterContextAdapterContext :: Typed.TypedName Coders.AdapterContext+adapterContextAdapterContext = Typed.TypedName (Core.Name "hydra.coders.AdapterContext")+ -- | DSL accessor for the adapters field of hydra.coders.AdapterContext adapterContextAdapters :: Typed.TypedTerm Coders.AdapterContext -> Typed.TypedTerm (M.Map Core.Name (Coders.Adapter Core.Type Core.Type Core.Term Core.Term Errors.Error)) adapterContextAdapters x =@@ -330,6 +340,10 @@           Core.fieldName = (Core.Name "decode"),           Core.fieldTerm = (Typed.unTypedTerm decode)}]})) +-- | DSL name token for hydra.coders.Bicoder+bicoderBicoder :: Typed.TypedName (Coders.Bicoder t1 t2 v1 v2 e)+bicoderBicoder = Typed.TypedName (Core.Name "hydra.coders.Bicoder")+ -- | DSL accessor for the decode field of hydra.coders.Bicoder bicoderDecode :: Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2 e) -> Typed.TypedTerm (t2 -> Coders.Adapter t2 t1 v2 v1 e) bicoderDecode x =@@ -419,6 +433,10 @@           Core.fieldName = (Core.Name "typeVariable"),           Core.fieldTerm = (Typed.unTypedTerm typeVariable)}]})) +-- | DSL name token for hydra.coders.CaseConventions+caseConventionsCaseConventions :: Typed.TypedName Coders.CaseConventions+caseConventionsCaseConventions = Typed.TypedName (Core.Name "hydra.coders.CaseConventions")+ -- | DSL accessor for the constant field of hydra.coders.CaseConventions caseConventionsConstant :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention caseConventionsConstant x =@@ -1252,6 +1270,10 @@           Core.fieldName = (Core.Name "decode"),           Core.fieldTerm = (Typed.unTypedTerm decode)}]})) +-- | DSL name token for hydra.coders.Coder+coderCoder :: Typed.TypedName (Coders.Coder v1 v2 e)+coderCoder = Typed.TypedName (Core.Name "hydra.coders.Coder")+ -- | DSL accessor for the decode field of hydra.coders.Coder coderDecode :: Typed.TypedTerm (Coders.Coder v1 v2 e) -> Typed.TypedTerm (v2 -> Either e v1) coderDecode x =@@ -1261,6 +1283,10 @@         Core.projectionFieldName = (Core.Name "decode")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.coders.CoderDirection+coderDirectionCoderDirection :: Typed.TypedName Coders.CoderDirection+coderDirectionCoderDirection = Typed.TypedName (Core.Name "hydra.coders.CoderDirection")+ -- | DSL injection for the decode variant of hydra.coders.CoderDirection coderDirectionDecode :: Typed.TypedTerm Coders.CoderDirection coderDirectionDecode =@@ -1322,6 +1348,88 @@               Core.projectionFieldName = (Core.Name "decode")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL composition builder for the decoder of hydra.coders.Adapter+decodeAdapter :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError e) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Coders.Adapter t1 t2 v1 v2 e))+decodeAdapter t1 t2 v1 v2 e =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.coders.adapter")),+              Core.applicationArgument = (Typed.unTypedTerm t1)})),+            Core.applicationArgument = (Typed.unTypedTerm t2)})),+          Core.applicationArgument = (Typed.unTypedTerm v1)})),+        Core.applicationArgument = (Typed.unTypedTerm v2)})),+      Core.applicationArgument = (Typed.unTypedTerm e)}))++-- | DSL composition builder for the decoder of hydra.coders.Bicoder+decodeBicoder :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError e) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Coders.Bicoder t1 t2 v1 v2 e))+decodeBicoder t1 t2 v1 v2 e =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.coders.bicoder")),+              Core.applicationArgument = (Typed.unTypedTerm t1)})),+            Core.applicationArgument = (Typed.unTypedTerm t2)})),+          Core.applicationArgument = (Typed.unTypedTerm v1)})),+        Core.applicationArgument = (Typed.unTypedTerm v2)})),+      Core.applicationArgument = (Typed.unTypedTerm e)}))++-- | DSL composition builder for the decoder of hydra.coders.Coder+decodeCoder :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError e) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Coders.Coder v1 v2 e))+decodeCoder v1 v2 e =+    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.decode.coders.coder")),+          Core.applicationArgument = (Typed.unTypedTerm v1)})),+        Core.applicationArgument = (Typed.unTypedTerm v2)})),+      Core.applicationArgument = (Typed.unTypedTerm e)}))++-- | DSL composition builder for the encoder of hydra.coders.Adapter+encodeAdapter :: Typed.TypedTerm (t1 -> Core.Term) -> Typed.TypedTerm (t2 -> Core.Term) -> Typed.TypedTerm (v1 -> Core.Term) -> Typed.TypedTerm (v2 -> Core.Term) -> Typed.TypedTerm (e -> Core.Term) -> Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2 e -> Core.Term)+encodeAdapter t1 t2 v1 v2 e =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.coders.adapter")),+              Core.applicationArgument = (Typed.unTypedTerm t1)})),+            Core.applicationArgument = (Typed.unTypedTerm t2)})),+          Core.applicationArgument = (Typed.unTypedTerm v1)})),+        Core.applicationArgument = (Typed.unTypedTerm v2)})),+      Core.applicationArgument = (Typed.unTypedTerm e)}))++-- | DSL composition builder for the encoder of hydra.coders.Bicoder+encodeBicoder :: Typed.TypedTerm (t1 -> Core.Term) -> Typed.TypedTerm (t2 -> Core.Term) -> Typed.TypedTerm (v1 -> Core.Term) -> Typed.TypedTerm (v2 -> Core.Term) -> Typed.TypedTerm (e -> Core.Term) -> Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2 e -> Core.Term)+encodeBicoder t1 t2 v1 v2 e =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.coders.bicoder")),+              Core.applicationArgument = (Typed.unTypedTerm t1)})),+            Core.applicationArgument = (Typed.unTypedTerm t2)})),+          Core.applicationArgument = (Typed.unTypedTerm v1)})),+        Core.applicationArgument = (Typed.unTypedTerm v2)})),+      Core.applicationArgument = (Typed.unTypedTerm e)}))++-- | DSL composition builder for the encoder of hydra.coders.Coder+encodeCoder :: Typed.TypedTerm (v1 -> Core.Term) -> Typed.TypedTerm (v2 -> Core.Term) -> Typed.TypedTerm (e -> Core.Term) -> Typed.TypedTerm (Coders.Coder v1 v2 e -> Core.Term)+encodeCoder v1 v2 e =+    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.encode.coders.coder")),+          Core.applicationArgument = (Typed.unTypedTerm v1)})),+        Core.applicationArgument = (Typed.unTypedTerm v2)})),+      Core.applicationArgument = (Typed.unTypedTerm e)}))+ -- | DSL constructor for hydra.coders.Language language :: Typed.TypedTerm Coders.LanguageName -> Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Coders.LanguageFeature) -> Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm File.FileExtension -> Typed.TypedTerm Coders.Language language name constraints supportedFeatures caseConventions defaultFileExtension =@@ -1405,6 +1513,10 @@         Core.projectionFieldName = (Core.Name "integerTypes")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.coders.LanguageConstraints+languageConstraintsLanguageConstraints :: Typed.TypedName Coders.LanguageConstraints+languageConstraintsLanguageConstraints = Typed.TypedName (Core.Name "hydra.coders.LanguageConstraints")+ -- | DSL accessor for the literalVariants field of hydra.coders.LanguageConstraints languageConstraintsLiteralVariants :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Variants.LiteralVariant) languageConstraintsLiteralVariants x =@@ -1720,6 +1832,10 @@         Core.projectionFieldName = (Core.Name "defaultFileExtension")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.coders.LanguageFeature+languageFeatureLanguageFeature :: Typed.TypedName Coders.LanguageFeature+languageFeatureLanguageFeature = Typed.TypedName (Core.Name "hydra.coders.LanguageFeature")+ -- | DSL injection for the nestedCaseStatements variant of hydra.coders.LanguageFeature languageFeatureNestedCaseStatements :: Typed.TypedTerm Coders.LanguageFeature languageFeatureNestedCaseStatements =@@ -1747,6 +1863,10 @@         Core.fieldName = (Core.Name "partialApplication"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.coders.Language+languageLanguage :: Typed.TypedName Coders.Language+languageLanguage = Typed.TypedName (Core.Name "hydra.coders.Language")+ -- | DSL accessor for the name field of hydra.coders.Language languageName :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.LanguageName languageName x =@@ -1763,6 +1883,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.coders.LanguageName+languageNameLanguageName :: Typed.TypedName Coders.LanguageName+languageNameLanguageName = Typed.TypedName (Core.Name "hydra.coders.LanguageName")+ -- | DSL accessor for the supportedFeatures field of hydra.coders.Language languageSupportedFeatures :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm (S.Set Coders.LanguageFeature) languageSupportedFeatures x =@@ -1979,6 +2103,10 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "pre"),         Core.fieldTerm = Core.TermUnit}}))++-- | DSL name token for hydra.coders.TraversalOrder+traversalOrderTraversalOrder :: Typed.TypedName Coders.TraversalOrder+traversalOrderTraversalOrder = Typed.TypedName (Core.Name "hydra.coders.TraversalOrder")  -- | DSL accessor for the body of hydra.coders.LanguageName unLanguageName :: Typed.TypedTerm Coders.LanguageName -> Typed.TypedTerm String

@@ -0,0 +1,144 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.constants++module Hydra.Dsl.Constants where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.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.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.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+ignoredVariable = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.ignoredVariable"))++-- | DSL reference to hydra.constants.keyClasses+keyClasses :: Typed.TypedTerm Core.Name+keyClasses = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyClasses"))++-- | DSL reference to hydra.constants.keyDebugId+keyDebugId :: Typed.TypedTerm Core.Name+keyDebugId = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyDebugId"))++-- | DSL reference to hydra.constants.keyDeprecated+keyDeprecated :: Typed.TypedTerm Core.Name+keyDeprecated = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyDeprecated"))++-- | DSL reference to hydra.constants.keyDescription+keyDescription :: Typed.TypedTerm Core.Name+keyDescription = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyDescription"))++-- | DSL reference to hydra.constants.keyExclude+keyExclude :: Typed.TypedTerm Core.Name+keyExclude = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyExclude"))++-- | DSL reference to hydra.constants.keyFirstClassType+keyFirstClassType :: Typed.TypedTerm Core.Name+keyFirstClassType = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyFirstClassType"))++-- | DSL reference to hydra.constants.keyFreshTypeVariableCount+keyFreshTypeVariableCount :: Typed.TypedTerm Core.Name+keyFreshTypeVariableCount = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyFreshTypeVariableCount"))++-- | DSL reference to hydra.constants.keyMaxLength+keyMaxLength :: Typed.TypedTerm Core.Name+keyMaxLength = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyMaxLength"))++-- | DSL reference to hydra.constants.keyMinLength+keyMinLength :: Typed.TypedTerm Core.Name+keyMinLength = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyMinLength"))++-- | DSL reference to hydra.constants.keyPreserveFieldName+keyPreserveFieldName :: Typed.TypedTerm Core.Name+keyPreserveFieldName = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyPreserveFieldName"))++-- | DSL reference to hydra.constants.keyType+keyType :: Typed.TypedTerm Core.Name+keyType = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyType"))++-- | DSL reference to hydra.constants.maxInt32+maxInt32 :: Typed.TypedTerm Int+maxInt32 = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.maxInt32"))++-- | DSL reference to hydra.constants.maxTraceDepth+maxTraceDepth :: Typed.TypedTerm Int+maxTraceDepth = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.maxTraceDepth"))++-- | DSL reference to hydra.constants.regexCamelCase+regexCamelCase :: Typed.TypedTerm String+regexCamelCase = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.regexCamelCase"))++-- | DSL reference to hydra.constants.regexNamespace+regexNamespace :: Typed.TypedTerm String+regexNamespace = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.regexNamespace"))++-- | DSL reference to hydra.constants.regexPackageName+regexPackageName :: Typed.TypedTerm String+regexPackageName = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.regexPackageName"))++-- | DSL reference to hydra.constants.regexPascalCase+regexPascalCase :: Typed.TypedTerm String+regexPascalCase = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.regexPascalCase"))++-- | DSL reference to hydra.constants.warningAutoGeneratedFile+warningAutoGeneratedFile :: Typed.TypedTerm String+warningAutoGeneratedFile = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.warningAutoGeneratedFile"))

@@ -5,6 +5,8 @@ module Hydra.Dsl.Core where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Typed as Typed import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci@@ -26,6 +28,10 @@           Core.fieldName = (Core.Name "annotation"),           Core.fieldTerm = (Typed.unTypedTerm annotation)}]})) +-- | DSL name token for hydra.core.AnnotatedTerm+annotatedTermAnnotatedTerm :: Typed.TypedName Core.AnnotatedTerm+annotatedTermAnnotatedTerm = Typed.TypedName (Core.Name "hydra.core.AnnotatedTerm")+ -- | DSL accessor for the annotation field of hydra.core.AnnotatedTerm annotatedTermAnnotation :: Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm Core.Term annotatedTermAnnotation x =@@ -91,6 +97,10 @@           Core.fieldName = (Core.Name "annotation"),           Core.fieldTerm = (Typed.unTypedTerm annotation)}]})) +-- | DSL name token for hydra.core.AnnotatedType+annotatedTypeAnnotatedType :: Typed.TypedName Core.AnnotatedType+annotatedTypeAnnotatedType = Typed.TypedName (Core.Name "hydra.core.AnnotatedType")+ -- | DSL accessor for the annotation field of hydra.core.AnnotatedType annotatedTypeAnnotation :: Typed.TypedTerm Core.AnnotatedType -> Typed.TypedTerm Core.Term annotatedTypeAnnotation x =@@ -156,6 +166,10 @@           Core.fieldName = (Core.Name "argument"),           Core.fieldTerm = (Typed.unTypedTerm argument)}]})) +-- | DSL name token for hydra.core.Application+applicationApplication :: Typed.TypedName Core.Application+applicationApplication = Typed.TypedName (Core.Name "hydra.core.Application")+ -- | DSL accessor for the argument field of hydra.core.Application applicationArgument :: Typed.TypedTerm Core.Application -> Typed.TypedTerm Core.Term applicationArgument x =@@ -187,6 +201,10 @@           Core.fieldName = (Core.Name "argument"),           Core.fieldTerm = (Typed.unTypedTerm argument)}]})) +-- | DSL name token for hydra.core.ApplicationType+applicationTypeApplicationType :: Typed.TypedName Core.ApplicationType+applicationTypeApplicationType = Typed.TypedName (Core.Name "hydra.core.ApplicationType")+ -- | DSL accessor for the argument field of hydra.core.ApplicationType applicationTypeArgument :: Typed.TypedTerm Core.ApplicationType -> Typed.TypedTerm Core.Type applicationTypeArgument x =@@ -289,6 +307,10 @@           Core.fieldName = (Core.Name "typeScheme"),           Core.fieldTerm = (Typed.unTypedTerm typeScheme)}]})) +-- | DSL name token for hydra.core.Binding+bindingBinding :: Typed.TypedName Core.Binding+bindingBinding = Typed.TypedName (Core.Name "hydra.core.Binding")+ -- | DSL accessor for the name field of hydra.core.Binding bindingName :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Core.Name bindingName x =@@ -401,6 +423,10 @@           Core.fieldName = (Core.Name "handler"),           Core.fieldTerm = (Typed.unTypedTerm handler)}]})) +-- | DSL name token for hydra.core.CaseAlternative+caseAlternativeCaseAlternative :: Typed.TypedName Core.CaseAlternative+caseAlternativeCaseAlternative = Typed.TypedName (Core.Name "hydra.core.CaseAlternative")+ -- | DSL accessor for the handler field of hydra.core.CaseAlternative caseAlternativeHandler :: Typed.TypedTerm Core.CaseAlternative -> Typed.TypedTerm Core.Term caseAlternativeHandler x =@@ -469,6 +495,10 @@           Core.fieldName = (Core.Name "cases"),           Core.fieldTerm = (Typed.unTypedTerm cases)}]})) +-- | DSL name token for hydra.core.CaseStatement+caseStatementCaseStatement :: Typed.TypedName Core.CaseStatement+caseStatementCaseStatement = Typed.TypedName (Core.Name "hydra.core.CaseStatement")+ -- | DSL accessor for the cases field of hydra.core.CaseStatement caseStatementCases :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm [Core.CaseAlternative] caseStatementCases x =@@ -581,6 +611,10 @@           Core.fieldName = (Core.Name "right"),           Core.fieldTerm = (Typed.unTypedTerm right)}]})) +-- | DSL name token for hydra.core.EitherType+eitherTypeEitherType :: Typed.TypedName Core.EitherType+eitherTypeEitherType = Typed.TypedName (Core.Name "hydra.core.EitherType")+ -- | DSL accessor for the left field of hydra.core.EitherType eitherTypeLeft :: Typed.TypedTerm Core.EitherType -> Typed.TypedTerm Core.Type eitherTypeLeft x =@@ -646,6 +680,10 @@           Core.fieldName = (Core.Name "term"),           Core.fieldTerm = (Typed.unTypedTerm term)}]})) +-- | DSL name token for hydra.core.Field+fieldField :: Typed.TypedName Core.Field+fieldField = Typed.TypedName (Core.Name "hydra.core.Field")+ -- | DSL accessor for the name field of hydra.core.Field fieldName :: Typed.TypedTerm Core.Field -> Typed.TypedTerm Core.Name fieldName x =@@ -677,6 +715,10 @@           Core.fieldName = (Core.Name "type"),           Core.fieldTerm = (Typed.unTypedTerm type_)}]})) +-- | DSL name token for hydra.core.FieldType+fieldTypeFieldType :: Typed.TypedName Core.FieldType+fieldTypeFieldType = Typed.TypedName (Core.Name "hydra.core.FieldType")+ -- | DSL accessor for the name field of hydra.core.FieldType fieldTypeName :: Typed.TypedTerm Core.FieldType -> Typed.TypedTerm Core.Name fieldTypeName x =@@ -781,6 +823,10 @@         Core.fieldName = (Core.Name "float64"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.core.FloatType+floatTypeFloatType :: Typed.TypedName Core.FloatType+floatTypeFloatType = Typed.TypedName (Core.Name "hydra.core.FloatType")+ -- | DSL injection for the float32 variant of hydra.core.FloatValue floatValueFloat32 :: Typed.TypedTerm Float -> Typed.TypedTerm Core.FloatValue floatValueFloat32 x =@@ -799,6 +845,10 @@         Core.fieldName = (Core.Name "float64"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.FloatValue+floatValueFloatValue :: Typed.TypedName Core.FloatValue+floatValueFloatValue = Typed.TypedName (Core.Name "hydra.core.FloatValue")+ -- | DSL constructor for hydra.core.ForallType forallType :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.ForallType forallType parameter body =@@ -821,6 +871,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.ForallType+forallTypeForallType :: Typed.TypedName Core.ForallType+forallTypeForallType = Typed.TypedName (Core.Name "hydra.core.ForallType")+ -- | DSL accessor for the parameter field of hydra.core.ForallType forallTypeParameter :: Typed.TypedTerm Core.ForallType -> Typed.TypedTerm Core.Name forallTypeParameter x =@@ -895,6 +949,10 @@         Core.projectionFieldName = (Core.Name "domain")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.FunctionType+functionTypeFunctionType :: Typed.TypedName Core.FunctionType+functionTypeFunctionType = Typed.TypedName (Core.Name "hydra.core.FunctionType")+ -- | DSL updater for the codomain field of hydra.core.FunctionType functionTypeWithCodomain :: Typed.TypedTerm Core.FunctionType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.FunctionType functionTypeWithCodomain original newVal =@@ -951,6 +1009,10 @@         Core.projectionFieldName = (Core.Name "field")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Injection+injectionInjection :: Typed.TypedName Core.Injection+injectionInjection = Typed.TypedName (Core.Name "hydra.core.Injection")+ -- | DSL accessor for the typeName field of hydra.core.Injection injectionTypeName :: Typed.TypedTerm Core.Injection -> Typed.TypedTerm Core.Name injectionTypeName x =@@ -1039,6 +1101,10 @@         Core.fieldName = (Core.Name "int8"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.core.IntegerType+integerTypeIntegerType :: Typed.TypedName Core.IntegerType+integerTypeIntegerType = Typed.TypedName (Core.Name "hydra.core.IntegerType")+ -- | DSL injection for the uint16 variant of hydra.core.IntegerType integerTypeUint16 :: Typed.TypedTerm Core.IntegerType integerTypeUint16 =@@ -1120,6 +1186,10 @@         Core.fieldName = (Core.Name "int8"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.IntegerValue+integerValueIntegerValue :: Typed.TypedName Core.IntegerValue+integerValueIntegerValue = Typed.TypedName (Core.Name "hydra.core.IntegerValue")+ -- | DSL injection for the uint16 variant of hydra.core.IntegerValue integerValueUint16 :: Typed.TypedTerm Int -> Typed.TypedTerm Core.IntegerValue integerValueUint16 x =@@ -1190,6 +1260,10 @@         Core.projectionFieldName = (Core.Name "domain")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Lambda+lambdaLambda :: Typed.TypedName Core.Lambda+lambdaLambda = Typed.TypedName (Core.Name "hydra.core.Lambda")+ -- | DSL accessor for the parameter field of hydra.core.Lambda lambdaParameter :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm Core.Name lambdaParameter x =@@ -1302,6 +1376,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Let+letLet :: Typed.TypedName Core.Let+letLet = Typed.TypedName (Core.Name "hydra.core.Let")+ -- | DSL updater for the bindings field of hydra.core.Let letWithBindings :: Typed.TypedTerm Core.Let -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Let letWithBindings original newVal =@@ -1381,6 +1459,10 @@         Core.fieldName = (Core.Name "integer"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.Literal+literalLiteral :: Typed.TypedName Core.Literal+literalLiteral = Typed.TypedName (Core.Name "hydra.core.Literal")+ -- | DSL injection for the string variant of hydra.core.Literal literalString :: Typed.TypedTerm String -> Typed.TypedTerm Core.Literal literalString x =@@ -1435,6 +1517,10 @@         Core.fieldName = (Core.Name "integer"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.LiteralType+literalTypeLiteralType :: Typed.TypedName Core.LiteralType+literalTypeLiteralType = Typed.TypedName (Core.Name "hydra.core.LiteralType")+ -- | DSL injection for the string variant of hydra.core.LiteralType literalTypeString :: Typed.TypedTerm Core.LiteralType literalTypeString =@@ -1466,6 +1552,10 @@         Core.projectionFieldName = (Core.Name "keys")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.MapType+mapTypeMapType :: Typed.TypedName Core.MapType+mapTypeMapType = Typed.TypedName (Core.Name "hydra.core.MapType")+ -- | DSL accessor for the values field of hydra.core.MapType mapTypeValues :: Typed.TypedTerm Core.MapType -> Typed.TypedTerm Core.Type mapTypeValues x =@@ -1516,6 +1606,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Name+nameName :: Typed.TypedName Core.Name+nameName = Typed.TypedName (Core.Name "hydra.core.Name")+ -- | DSL constructor for hydra.core.PairType pairType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.PairType pairType first second =@@ -1538,6 +1632,10 @@         Core.projectionFieldName = (Core.Name "first")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.PairType+pairTypePairType :: Typed.TypedName Core.PairType+pairTypePairType = Typed.TypedName (Core.Name "hydra.core.PairType")+ -- | DSL accessor for the second field of hydra.core.PairType pairTypeSecond :: Typed.TypedTerm Core.PairType -> Typed.TypedTerm Core.Type pairTypeSecond x =@@ -1603,6 +1701,10 @@         Core.projectionFieldName = (Core.Name "fieldName")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Projection+projectionProjection :: Typed.TypedName Core.Projection+projectionProjection = Typed.TypedName (Core.Name "hydra.core.Projection")+ -- | DSL accessor for the typeName field of hydra.core.Projection projectionTypeName :: Typed.TypedTerm Core.Projection -> Typed.TypedTerm Core.Name projectionTypeName x =@@ -1668,6 +1770,10 @@         Core.projectionFieldName = (Core.Name "fields")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Record+recordRecord :: Typed.TypedName Core.Record+recordRecord = Typed.TypedName (Core.Name "hydra.core.Record")+ -- | DSL accessor for the typeName field of hydra.core.Record recordTypeName :: Typed.TypedTerm Core.Record -> Typed.TypedTerm Core.Name recordTypeName x =@@ -1846,6 +1952,10 @@         Core.fieldName = (Core.Name "set"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.Term+termTerm :: Typed.TypedName Core.Term+termTerm = Typed.TypedName (Core.Name "hydra.core.Term")+ -- | DSL injection for the typeApplication variant of hydra.core.Term termTypeApplication :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Term termTypeApplication x =@@ -1949,6 +2059,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.TypeApplicationTerm+typeApplicationTermTypeApplicationTerm :: Typed.TypedName Core.TypeApplicationTerm+typeApplicationTermTypeApplicationTerm = Typed.TypedName (Core.Name "hydra.core.TypeApplicationTerm")+ -- | DSL updater for the body field of hydra.core.TypeApplicationTerm typeApplicationTermWithBody :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.TypeApplicationTerm typeApplicationTermWithBody original newVal =@@ -1992,6 +2106,10 @@         Core.fieldName = (Core.Name "simple"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.TypeClassConstraint+typeClassConstraintTypeClassConstraint :: Typed.TypedName Core.TypeClassConstraint+typeClassConstraintTypeClassConstraint = Typed.TypedName (Core.Name "hydra.core.TypeClassConstraint")+ -- | DSL injection for the effect variant of hydra.core.Type typeEffect :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type typeEffect x =@@ -2059,6 +2177,10 @@         Core.projectionFieldName = (Core.Name "parameter")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.TypeLambda+typeLambdaTypeLambda :: Typed.TypedName Core.TypeLambda+typeLambdaTypeLambda = Typed.TypedName (Core.Name "hydra.core.TypeLambda")+ -- | DSL updater for the body field of hydra.core.TypeLambda typeLambdaWithBody :: Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.TypeLambda typeLambdaWithBody original newVal =@@ -2181,6 +2303,10 @@         Core.projectionFieldName = (Core.Name "constraints")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.TypeScheme+typeSchemeTypeScheme :: Typed.TypedName Core.TypeScheme+typeSchemeTypeScheme = Typed.TypedName (Core.Name "hydra.core.TypeScheme")+ -- | DSL accessor for the variables field of hydra.core.TypeScheme typeSchemeVariables :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm [Core.Name] typeSchemeVariables x =@@ -2271,6 +2397,10 @@         Core.fieldName = (Core.Name "set"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.Type+typeType :: Typed.TypedName Core.Type+typeType = Typed.TypedName (Core.Name "hydra.core.Type")+ -- | DSL injection for the union variant of hydra.core.Type typeUnion :: Typed.TypedTerm [Core.FieldType] -> Typed.TypedTerm Core.Type typeUnion x =@@ -2317,6 +2447,10 @@         Core.projectionFieldName = (Core.Name "classes")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.TypeVariableConstraints+typeVariableConstraintsTypeVariableConstraints :: Typed.TypedName Core.TypeVariableConstraints+typeVariableConstraintsTypeVariableConstraints = Typed.TypedName (Core.Name "hydra.core.TypeVariableConstraints")+ -- | DSL updater for the classes field of hydra.core.TypeVariableConstraints typeVariableConstraintsWithClasses :: Typed.TypedTerm Core.TypeVariableConstraints -> Typed.TypedTerm [Core.TypeClassConstraint] -> Typed.TypedTerm Core.TypeVariableConstraints typeVariableConstraintsWithClasses original newVal =@@ -2416,3 +2550,7 @@               Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),               Core.projectionFieldName = (Core.Name "body")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL name token for hydra.core.WrappedTerm+wrappedTermWrappedTerm :: Typed.TypedName Core.WrappedTerm+wrappedTermWrappedTerm = Typed.TypedName (Core.Name "hydra.core.WrappedTerm")

@@ -0,0 +1,203 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.dependencies++module Hydra.Dsl.Dependencies where++import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Dependencies as Dependencies+import qualified Hydra.Docs as Docs+import qualified Hydra.Dsl.Annotations as DslAnnotations+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Constants as DslConstants+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.Lexical as DslLexical+import qualified Hydra.Dsl.Names as DslNames+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.Rewriting as DslRewriting+import qualified Hydra.Dsl.Sorting as DslSorting+import qualified Hydra.Dsl.Strip as DslStrip+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.Variables as DslVariables+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.Lexical as Lexical+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Sorting as Sorting+import qualified Hydra.Strip as Strip+import qualified Hydra.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.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S++-- | DSL reference to hydra.dependencies.definitionsWithDependencies+definitionsWithDependencies :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Either Errors.Error [Core.Binding])+definitionsWithDependencies 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.dependencies.definitionsWithDependencies")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.dependencies.flattenLetTerms+flattenLetTerms :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+flattenLetTerms arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.flattenLetTerms")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.inlineType+inlineType :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error Core.Type)+inlineType arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.inlineType")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.dependencies.isLambda+isLambda :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isLambda arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.isLambda")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.liftLambdaAboveLet+liftLambdaAboveLet :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+liftLambdaAboveLet arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.liftLambdaAboveLet")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.pruneLet+pruneLet :: Typed.TypedTerm Core.Let -> Typed.TypedTerm Core.Let+pruneLet arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.pruneLet")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.replaceTypedefs+replaceTypedefs :: Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+replaceTypedefs arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.replaceTypedefs")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.dependencies.simplifyTerm+simplifyTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+simplifyTerm arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.simplifyTerm")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.termDependencyNames+termDependencyNames :: Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (S.Set Core.Name)+termDependencyNames 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.dependencies.termDependencyNames")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.dependencies.toShortNames+toShortNames :: Typed.TypedTerm [Core.Name] -> Typed.TypedTerm (M.Map Core.Name Core.Name)+toShortNames arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.toShortNames")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.topologicalSortBindingMap+topologicalSortBindingMap :: Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm [[(Core.Name, Core.Term)]]+topologicalSortBindingMap arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.topologicalSortBindingMap")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.topologicalSortBindings+topologicalSortBindings :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Either [[Core.Name]] [Core.Name])+topologicalSortBindings arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.topologicalSortBindings")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.topologicalSortTypeDefinitions+topologicalSortTypeDefinitions :: Typed.TypedTerm [Packaging.TypeDefinition] -> Typed.TypedTerm [[Packaging.TypeDefinition]]+topologicalSortTypeDefinitions arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.topologicalSortTypeDefinitions")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.dependencies.typeDependencyNames+typeDependencyNames :: Typed.TypedTerm Bool -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (S.Set Core.Name)+typeDependencyNames arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.typeDependencyNames")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.dependencies.typeNamesInType+typeNamesInType :: Ord t0 => (Typed.TypedTerm Core.Type -> Typed.TypedTerm (S.Set t0))+typeNamesInType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.typeNamesInType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -5,12 +5,18 @@ module Hydra.Dsl.Docs where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Docs as DecodeDocs import qualified Hydra.Docs as Docs import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Encode.Docs as EncodeDocs import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci++-- | DSL name token for hydra.docs.DocSegment+docSegmentDocSegment :: Typed.TypedName Docs.DocSegment+docSegmentDocSegment = Typed.TypedName (Core.Name "hydra.docs.DocSegment")  -- | DSL injection for the ref variant of hydra.docs.DocSegment docSegmentRef :: Typed.TypedTerm Packaging.EntityReference -> Typed.TypedTerm Docs.DocSegment

@@ -0,0 +1,193 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.environment++module Hydra.Dsl.Environment where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.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.Lexical as DslLexical+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.Scoping as DslScoping+import qualified Hydra.Dsl.Sorting as DslSorting+import qualified Hydra.Dsl.Strip as DslStrip+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.Variables as DslVariables+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Environment as Environment+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.Lexical as Lexical+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Sorting as Sorting+import qualified Hydra.Strip as Strip+import qualified Hydra.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.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M++-- | DSL reference to hydra.environment.definitionAsTypeApplicationTerm+definitionAsTypeApplicationTerm :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm (Either Errors.Error Core.TypeApplicationTerm)+definitionAsTypeApplicationTerm arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.definitionAsTypeApplicationTerm")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.environment.graphAsLet+graphAsLet :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Let+graphAsLet arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.graphAsLet")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.environment.graphAsTerm+graphAsTerm :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+graphAsTerm arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.graphAsTerm")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.environment.graphAsTypes+graphAsTypes :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Either Errors.DecodingError (M.Map Core.Name Core.Type))+graphAsTypes arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.graphAsTypes")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.environment.partitionDefinitions+partitionDefinitions :: Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm ([Packaging.TypeDefinition], [Packaging.TermDefinition])+partitionDefinitions arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.partitionDefinitions")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.environment.reorderDefs+reorderDefs :: Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm [Packaging.Definition]+reorderDefs arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.reorderDefs")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.environment.schemaGraphToTypingEnvironment+schemaGraphToTypingEnvironment :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (Either Errors.Error (M.Map Core.Name Core.TypeScheme))+schemaGraphToTypingEnvironment arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.schemaGraphToTypingEnvironment")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.environment.termAsBindings+termAsBindings :: Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Binding]+termAsBindings arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.termAsBindings")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.environment.typesToDefinitions+typesToDefinitions :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm [Core.Binding]+typesToDefinitions arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.typesToDefinitions")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.environment.withLambdaContext+withLambdaContext :: Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t1) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Lambda -> Typed.TypedTerm (t1 -> t2) -> Typed.TypedTerm t2+withLambdaContext arg0 arg1 arg2 arg3 arg4 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.withLambdaContext")),+              Core.applicationArgument = (Typed.unTypedTerm arg0)})),+            Core.applicationArgument = (Typed.unTypedTerm arg1)})),+          Core.applicationArgument = (Typed.unTypedTerm arg2)})),+        Core.applicationArgument = (Typed.unTypedTerm arg3)})),+      Core.applicationArgument = (Typed.unTypedTerm arg4)}))++-- | DSL reference to hydra.environment.withLetContext+withLetContext :: Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t1) -> Typed.TypedTerm (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Let -> Typed.TypedTerm (t1 -> t2) -> Typed.TypedTerm t2+withLetContext arg0 arg1 arg2 arg3 arg4 arg5 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.withLetContext")),+                Core.applicationArgument = (Typed.unTypedTerm arg0)})),+              Core.applicationArgument = (Typed.unTypedTerm arg1)})),+            Core.applicationArgument = (Typed.unTypedTerm arg2)})),+          Core.applicationArgument = (Typed.unTypedTerm arg3)})),+        Core.applicationArgument = (Typed.unTypedTerm arg4)})),+      Core.applicationArgument = (Typed.unTypedTerm arg5)}))++-- | DSL reference to hydra.environment.withTypeLambdaContext+withTypeLambdaContext :: Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t1) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm (t1 -> t2) -> Typed.TypedTerm t2+withTypeLambdaContext arg0 arg1 arg2 arg3 arg4 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.withTypeLambdaContext")),+              Core.applicationArgument = (Typed.unTypedTerm arg0)})),+            Core.applicationArgument = (Typed.unTypedTerm arg1)})),+          Core.applicationArgument = (Typed.unTypedTerm arg2)})),+        Core.applicationArgument = (Typed.unTypedTerm arg3)})),+      Core.applicationArgument = (Typed.unTypedTerm arg4)}))

@@ -5,10 +5,12 @@ module Hydra.Dsl.Error.Checking where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Error.Checking as DecodeErrorChecking import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Typing as DslTyping import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Encode.Error.Checking as EncodeErrorChecking import qualified Hydra.Error.Checking as Checking import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed@@ -18,6 +20,10 @@ import qualified Data.Scientific as Sci import qualified Data.Set as S +-- | DSL name token for hydra.error.checking.CheckingError+checkingErrorCheckingError :: Typed.TypedName Checking.CheckingError+checkingErrorCheckingError = Typed.TypedName (Core.Name "hydra.error.checking.CheckingError")+ -- | DSL injection for the incorrectUnification variant of hydra.error.checking.CheckingError checkingErrorIncorrectUnification :: Typed.TypedTerm Checking.IncorrectUnificationError -> Typed.TypedTerm Checking.CheckingError checkingErrorIncorrectUnification x =@@ -145,6 +151,11 @@           Core.fieldName = (Core.Name "substitution"),           Core.fieldTerm = (Typed.unTypedTerm substitution)}]})) +-- | DSL name token for hydra.error.checking.IncorrectUnificationError+incorrectUnificationErrorIncorrectUnificationError :: Typed.TypedName Checking.IncorrectUnificationError+incorrectUnificationErrorIncorrectUnificationError =+    Typed.TypedName (Core.Name "hydra.error.checking.IncorrectUnificationError")+ -- | DSL accessor for the substitution field of hydra.error.checking.IncorrectUnificationError incorrectUnificationErrorSubstitution :: Typed.TypedTerm Checking.IncorrectUnificationError -> Typed.TypedTerm Typing.TypeSubst incorrectUnificationErrorSubstitution x =@@ -177,6 +188,10 @@           Core.fieldName = (Core.Name "typeArguments"),           Core.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) +-- | DSL name token for hydra.error.checking.NotAForallTypeError+notAForallTypeErrorNotAForallTypeError :: Typed.TypedName Checking.NotAForallTypeError+notAForallTypeErrorNotAForallTypeError = Typed.TypedName (Core.Name "hydra.error.checking.NotAForallTypeError")+ -- | DSL accessor for the type field of hydra.error.checking.NotAForallTypeError notAForallTypeErrorType :: Typed.TypedTerm Checking.NotAForallTypeError -> Typed.TypedTerm Core.Type notAForallTypeErrorType x =@@ -239,6 +254,10 @@           Core.fieldName = (Core.Name "type"),           Core.fieldTerm = (Typed.unTypedTerm type_)}]})) +-- | DSL name token for hydra.error.checking.NotAFunctionTypeError+notAFunctionTypeErrorNotAFunctionTypeError :: Typed.TypedName Checking.NotAFunctionTypeError+notAFunctionTypeErrorNotAFunctionTypeError = Typed.TypedName (Core.Name "hydra.error.checking.NotAFunctionTypeError")+ -- | DSL accessor for the type field of hydra.error.checking.NotAFunctionTypeError notAFunctionTypeErrorType :: Typed.TypedTerm Checking.NotAFunctionTypeError -> Typed.TypedTerm Core.Type notAFunctionTypeErrorType x =@@ -280,6 +299,10 @@         Core.projectionFieldName = (Core.Name "message")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.OtherCheckingError+otherCheckingErrorOtherCheckingError :: Typed.TypedName Checking.OtherCheckingError+otherCheckingErrorOtherCheckingError = Typed.TypedName (Core.Name "hydra.error.checking.OtherCheckingError")+ -- | DSL accessor for the path field of hydra.error.checking.OtherCheckingError otherCheckingErrorPath :: Typed.TypedTerm Checking.OtherCheckingError -> Typed.TypedTerm Paths.SubtermPath otherCheckingErrorPath x =@@ -378,6 +401,10 @@         Core.projectionFieldName = (Core.Name "typeArguments")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorTypeArityMismatchError :: Typed.TypedName Checking.TypeArityMismatchError+typeArityMismatchErrorTypeArityMismatchError = Typed.TypedName (Core.Name "hydra.error.checking.TypeArityMismatchError")+ -- | DSL updater for the actualArity field of hydra.error.checking.TypeArityMismatchError typeArityMismatchErrorWithActualArity :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Int -> Typed.TypedTerm Checking.TypeArityMismatchError typeArityMismatchErrorWithActualArity original newVal =@@ -533,6 +560,10 @@         Core.projectionFieldName = (Core.Name "expectedType")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.TypeMismatchError+typeMismatchErrorTypeMismatchError :: Typed.TypedName Checking.TypeMismatchError+typeMismatchErrorTypeMismatchError = Typed.TypedName (Core.Name "hydra.error.checking.TypeMismatchError")+ -- | DSL updater for the actualType field of hydra.error.checking.TypeMismatchError typeMismatchErrorWithActualType :: Typed.TypedTerm Checking.TypeMismatchError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.TypeMismatchError typeMismatchErrorWithActualType original newVal =@@ -589,6 +620,11 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UnboundTypeVariablesError+unboundTypeVariablesErrorUnboundTypeVariablesError :: Typed.TypedName Checking.UnboundTypeVariablesError+unboundTypeVariablesErrorUnboundTypeVariablesError =+    Typed.TypedName (Core.Name "hydra.error.checking.UnboundTypeVariablesError")+ -- | DSL accessor for the variables field of hydra.error.checking.UnboundTypeVariablesError unboundTypeVariablesErrorVariables :: Typed.TypedTerm Checking.UnboundTypeVariablesError -> Typed.TypedTerm (S.Set Core.Name) unboundTypeVariablesErrorVariables x =@@ -663,6 +699,11 @@         Core.projectionFieldName = (Core.Name "path")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingErrorUndefinedTermVariableCheckingError :: Typed.TypedName Checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingErrorUndefinedTermVariableCheckingError =+    Typed.TypedName (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError")+ -- | DSL updater for the name field of hydra.error.checking.UndefinedTermVariableCheckingError undefinedTermVariableCheckingErrorWithName :: Typed.TypedTerm Checking.UndefinedTermVariableCheckingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Checking.UndefinedTermVariableCheckingError undefinedTermVariableCheckingErrorWithName original newVal =@@ -728,6 +769,10 @@         Core.projectionFieldName = (Core.Name "types")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UnequalTypesError+unequalTypesErrorUnequalTypesError :: Typed.TypedName Checking.UnequalTypesError+unequalTypesErrorUnequalTypesError = Typed.TypedName (Core.Name "hydra.error.checking.UnequalTypesError")+ -- | DSL updater for the description field of hydra.error.checking.UnequalTypesError unequalTypesErrorWithDescription :: Typed.TypedTerm Checking.UnequalTypesError -> Typed.TypedTerm String -> Typed.TypedTerm Checking.UnequalTypesError unequalTypesErrorWithDescription original newVal =@@ -781,6 +826,11 @@         Core.projectionFieldName = (Core.Name "termVariant")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UnsupportedTermVariantError+unsupportedTermVariantErrorUnsupportedTermVariantError :: Typed.TypedName Checking.UnsupportedTermVariantError+unsupportedTermVariantErrorUnsupportedTermVariantError =+    Typed.TypedName (Core.Name "hydra.error.checking.UnsupportedTermVariantError")+ -- | DSL updater for the termVariant field of hydra.error.checking.UnsupportedTermVariantError unsupportedTermVariantErrorWithTermVariant :: Typed.TypedTerm Checking.UnsupportedTermVariantError -> Typed.TypedTerm Variants.TermVariant -> Typed.TypedTerm Checking.UnsupportedTermVariantError unsupportedTermVariantErrorWithTermVariant original newVal =@@ -798,6 +848,10 @@       Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"),       Core.recordFields = []})) +-- | DSL name token for hydra.error.checking.UntypedLambdaError+untypedLambdaErrorUntypedLambdaError :: Typed.TypedName Checking.UntypedLambdaError+untypedLambdaErrorUntypedLambdaError = Typed.TypedName (Core.Name "hydra.error.checking.UntypedLambdaError")+ -- | DSL constructor for hydra.error.checking.UntypedLetBindingError untypedLetBindingError :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Checking.UntypedLetBindingError untypedLetBindingError binding =@@ -817,6 +871,10 @@         Core.projectionFieldName = (Core.Name "binding")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UntypedLetBindingError+untypedLetBindingErrorUntypedLetBindingError :: Typed.TypedName Checking.UntypedLetBindingError+untypedLetBindingErrorUntypedLetBindingError = Typed.TypedName (Core.Name "hydra.error.checking.UntypedLetBindingError")+ -- | DSL updater for the binding field of hydra.error.checking.UntypedLetBindingError untypedLetBindingErrorWithBinding :: Typed.TypedTerm Checking.UntypedLetBindingError -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm Checking.UntypedLetBindingError untypedLetBindingErrorWithBinding original newVal =@@ -857,6 +915,11 @@         Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),         Core.projectionFieldName = (Core.Name "path")})),       Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.error.checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingErrorUntypedTermVariableCheckingError :: Typed.TypedName Checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingErrorUntypedTermVariableCheckingError =+    Typed.TypedName (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError")  -- | DSL updater for the name field of hydra.error.checking.UntypedTermVariableCheckingError untypedTermVariableCheckingErrorWithName :: Typed.TypedTerm Checking.UntypedTermVariableCheckingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Checking.UntypedTermVariableCheckingError

@@ -5,9 +5,11 @@ module Hydra.Dsl.Error.Core where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Error.Core as DecodeErrorCore import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Encode.Error.Core as EncodeErrorCore import qualified Hydra.Error.Core as ErrorCore import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed@@ -28,6 +30,10 @@           Core.fieldName = (Core.Name "value"),           Core.fieldTerm = (Typed.unTypedTerm value)}]})) +-- | DSL name token for hydra.error.core.ConstantConditionError+constantConditionErrorConstantConditionError :: Typed.TypedName ErrorCore.ConstantConditionError+constantConditionErrorConstantConditionError = Typed.TypedName (Core.Name "hydra.error.core.ConstantConditionError")+ -- | DSL accessor for the location field of hydra.error.core.ConstantConditionError constantConditionErrorLocation :: Typed.TypedTerm ErrorCore.ConstantConditionError -> Typed.TypedTerm Paths.SubtermPath constantConditionErrorLocation x =@@ -93,6 +99,10 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.DuplicateBindingError+duplicateBindingErrorDuplicateBindingError :: Typed.TypedName ErrorCore.DuplicateBindingError+duplicateBindingErrorDuplicateBindingError = Typed.TypedName (Core.Name "hydra.error.core.DuplicateBindingError")+ -- | DSL accessor for the location field of hydra.error.core.DuplicateBindingError duplicateBindingErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateBindingError -> Typed.TypedTerm Paths.SubtermPath duplicateBindingErrorLocation x =@@ -158,6 +168,10 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.DuplicateFieldError+duplicateFieldErrorDuplicateFieldError :: Typed.TypedName ErrorCore.DuplicateFieldError+duplicateFieldErrorDuplicateFieldError = Typed.TypedName (Core.Name "hydra.error.core.DuplicateFieldError")+ -- | DSL accessor for the location field of hydra.error.core.DuplicateFieldError duplicateFieldErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateFieldError -> Typed.TypedTerm Paths.SubtermPath duplicateFieldErrorLocation x =@@ -223,6 +237,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesErrorDuplicateRecordTypeFieldNamesError :: Typed.TypedName ErrorCore.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesErrorDuplicateRecordTypeFieldNamesError =+    Typed.TypedName (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError")+ -- | DSL accessor for the location field of hydra.error.core.DuplicateRecordTypeFieldNamesError duplicateRecordTypeFieldNamesErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError -> Typed.TypedTerm Paths.SubtermPath duplicateRecordTypeFieldNamesErrorLocation x =@@ -288,6 +307,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesErrorDuplicateUnionTypeFieldNamesError :: Typed.TypedName ErrorCore.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesErrorDuplicateUnionTypeFieldNamesError =+    Typed.TypedName (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError")+ -- | DSL accessor for the location field of hydra.error.core.DuplicateUnionTypeFieldNamesError duplicateUnionTypeFieldNamesErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError -> Typed.TypedTerm Paths.SubtermPath duplicateUnionTypeFieldNamesErrorLocation x =@@ -353,6 +377,10 @@           Core.fieldName = (Core.Name "typeName"),           Core.fieldTerm = (Typed.unTypedTerm typeName)}]})) +-- | DSL name token for hydra.error.core.EmptyCaseStatementError+emptyCaseStatementErrorEmptyCaseStatementError :: Typed.TypedName ErrorCore.EmptyCaseStatementError+emptyCaseStatementErrorEmptyCaseStatementError = Typed.TypedName (Core.Name "hydra.error.core.EmptyCaseStatementError")+ -- | DSL accessor for the location field of hydra.error.core.EmptyCaseStatementError emptyCaseStatementErrorLocation :: Typed.TypedTerm ErrorCore.EmptyCaseStatementError -> Typed.TypedTerm Paths.SubtermPath emptyCaseStatementErrorLocation x =@@ -415,6 +443,10 @@           Core.fieldName = (Core.Name "location"),           Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyLetBindingsError+emptyLetBindingsErrorEmptyLetBindingsError :: Typed.TypedName ErrorCore.EmptyLetBindingsError+emptyLetBindingsErrorEmptyLetBindingsError = Typed.TypedName (Core.Name "hydra.error.core.EmptyLetBindingsError")+ -- | DSL accessor for the location field of hydra.error.core.EmptyLetBindingsError emptyLetBindingsErrorLocation :: Typed.TypedTerm ErrorCore.EmptyLetBindingsError -> Typed.TypedTerm Paths.SubtermPath emptyLetBindingsErrorLocation x =@@ -444,6 +476,10 @@           Core.fieldName = (Core.Name "location"),           Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyRecordTypeError+emptyRecordTypeErrorEmptyRecordTypeError :: Typed.TypedName ErrorCore.EmptyRecordTypeError+emptyRecordTypeErrorEmptyRecordTypeError = Typed.TypedName (Core.Name "hydra.error.core.EmptyRecordTypeError")+ -- | DSL accessor for the location field of hydra.error.core.EmptyRecordTypeError emptyRecordTypeErrorLocation :: Typed.TypedTerm ErrorCore.EmptyRecordTypeError -> Typed.TypedTerm Paths.SubtermPath emptyRecordTypeErrorLocation x =@@ -473,6 +509,10 @@           Core.fieldName = (Core.Name "location"),           Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyTermAnnotationError+emptyTermAnnotationErrorEmptyTermAnnotationError :: Typed.TypedName ErrorCore.EmptyTermAnnotationError+emptyTermAnnotationErrorEmptyTermAnnotationError = Typed.TypedName (Core.Name "hydra.error.core.EmptyTermAnnotationError")+ -- | DSL accessor for the location field of hydra.error.core.EmptyTermAnnotationError emptyTermAnnotationErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTermAnnotationError -> Typed.TypedTerm Paths.SubtermPath emptyTermAnnotationErrorLocation x =@@ -502,6 +542,10 @@           Core.fieldName = (Core.Name "location"),           Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyTypeAnnotationError+emptyTypeAnnotationErrorEmptyTypeAnnotationError :: Typed.TypedName ErrorCore.EmptyTypeAnnotationError+emptyTypeAnnotationErrorEmptyTypeAnnotationError = Typed.TypedName (Core.Name "hydra.error.core.EmptyTypeAnnotationError")+ -- | DSL accessor for the location field of hydra.error.core.EmptyTypeAnnotationError emptyTypeAnnotationErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTypeAnnotationError -> Typed.TypedTerm Paths.SubtermPath emptyTypeAnnotationErrorLocation x =@@ -531,6 +575,10 @@           Core.fieldName = (Core.Name "location"),           Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyTypeNameInTermError+emptyTypeNameInTermErrorEmptyTypeNameInTermError :: Typed.TypedName ErrorCore.EmptyTypeNameInTermError+emptyTypeNameInTermErrorEmptyTypeNameInTermError = Typed.TypedName (Core.Name "hydra.error.core.EmptyTypeNameInTermError")+ -- | DSL accessor for the location field of hydra.error.core.EmptyTypeNameInTermError emptyTypeNameInTermErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTypeNameInTermError -> Typed.TypedTerm Paths.SubtermPath emptyTypeNameInTermErrorLocation x =@@ -560,6 +608,10 @@           Core.fieldName = (Core.Name "location"),           Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyUnionTypeError+emptyUnionTypeErrorEmptyUnionTypeError :: Typed.TypedName ErrorCore.EmptyUnionTypeError+emptyUnionTypeErrorEmptyUnionTypeError = Typed.TypedName (Core.Name "hydra.error.core.EmptyUnionTypeError")+ -- | DSL accessor for the location field of hydra.error.core.EmptyUnionTypeError emptyUnionTypeErrorLocation :: Typed.TypedTerm ErrorCore.EmptyUnionTypeError -> Typed.TypedTerm Paths.SubtermPath emptyUnionTypeErrorLocation x =@@ -592,6 +644,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidForallParameterNameError+invalidForallParameterNameErrorInvalidForallParameterNameError :: Typed.TypedName ErrorCore.InvalidForallParameterNameError+invalidForallParameterNameErrorInvalidForallParameterNameError =+    Typed.TypedName (Core.Name "hydra.error.core.InvalidForallParameterNameError")+ -- | DSL accessor for the location field of hydra.error.core.InvalidForallParameterNameError invalidForallParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidForallParameterNameError -> Typed.TypedTerm Paths.SubtermPath invalidForallParameterNameErrorLocation x =@@ -657,6 +714,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidLambdaParameterNameError+invalidLambdaParameterNameErrorInvalidLambdaParameterNameError :: Typed.TypedName ErrorCore.InvalidLambdaParameterNameError+invalidLambdaParameterNameErrorInvalidLambdaParameterNameError =+    Typed.TypedName (Core.Name "hydra.error.core.InvalidLambdaParameterNameError")+ -- | DSL accessor for the location field of hydra.error.core.InvalidLambdaParameterNameError invalidLambdaParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError -> Typed.TypedTerm Paths.SubtermPath invalidLambdaParameterNameErrorLocation x =@@ -722,6 +784,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidLetBindingNameError+invalidLetBindingNameErrorInvalidLetBindingNameError :: Typed.TypedName ErrorCore.InvalidLetBindingNameError+invalidLetBindingNameErrorInvalidLetBindingNameError =+    Typed.TypedName (Core.Name "hydra.error.core.InvalidLetBindingNameError")+ -- | DSL accessor for the location field of hydra.error.core.InvalidLetBindingNameError invalidLetBindingNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidLetBindingNameError -> Typed.TypedTerm Paths.SubtermPath invalidLetBindingNameErrorLocation x =@@ -774,6 +841,10 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.error.core.InvalidLiteralError+invalidLiteralErrorInvalidLiteralError :: Typed.TypedName ErrorCore.InvalidLiteralError+invalidLiteralErrorInvalidLiteralError = Typed.TypedName (Core.Name "hydra.error.core.InvalidLiteralError")+ -- | DSL injection for the typeMismatch variant of hydra.error.core.InvalidLiteralError invalidLiteralErrorTypeMismatch :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm ErrorCore.InvalidLiteralError invalidLiteralErrorTypeMismatch x =@@ -864,6 +935,10 @@         Core.fieldName = (Core.Name "invalidLetBindingName"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.error.core.InvalidTermError+invalidTermErrorInvalidTermError :: Typed.TypedName ErrorCore.InvalidTermError+invalidTermErrorInvalidTermError = Typed.TypedName (Core.Name "hydra.error.core.InvalidTermError")+ -- | DSL injection for the invalidTypeLambdaParameterName variant of hydra.error.core.InvalidTermError invalidTermErrorInvalidTypeLambdaParameterName :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm ErrorCore.InvalidTermError invalidTermErrorInvalidTypeLambdaParameterName x =@@ -1035,6 +1110,10 @@         Core.fieldName = (Core.Name "invalidForallParameterName"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.error.core.InvalidTypeError+invalidTypeErrorInvalidTypeError :: Typed.TypedName ErrorCore.InvalidTypeError+invalidTypeErrorInvalidTypeError = Typed.TypedName (Core.Name "hydra.error.core.InvalidTypeError")+ -- | DSL injection for the invalidTypeSchemeVariableName variant of hydra.error.core.InvalidTypeError invalidTypeErrorInvalidTypeSchemeVariableName :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm ErrorCore.InvalidTypeError invalidTypeErrorInvalidTypeSchemeVariableName x =@@ -1120,6 +1199,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameErrorInvalidTypeLambdaParameterNameError :: Typed.TypedName ErrorCore.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameErrorInvalidTypeLambdaParameterNameError =+    Typed.TypedName (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError")+ -- | DSL accessor for the location field of hydra.error.core.InvalidTypeLambdaParameterNameError invalidTypeLambdaParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm Paths.SubtermPath invalidTypeLambdaParameterNameErrorLocation x =@@ -1185,6 +1269,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameErrorInvalidTypeSchemeVariableNameError :: Typed.TypedName ErrorCore.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameErrorInvalidTypeSchemeVariableNameError =+    Typed.TypedName (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError")+ -- | DSL accessor for the location field of hydra.error.core.InvalidTypeSchemeVariableNameError invalidTypeSchemeVariableNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm Paths.SubtermPath invalidTypeSchemeVariableNameErrorLocation x =@@ -1268,6 +1357,10 @@         Core.projectionFieldName = (Core.Name "expectedType")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.LiteralTypeMismatchError+literalTypeMismatchErrorLiteralTypeMismatchError :: Typed.TypedName ErrorCore.LiteralTypeMismatchError+literalTypeMismatchErrorLiteralTypeMismatchError = Typed.TypedName (Core.Name "hydra.error.core.LiteralTypeMismatchError")+ -- | DSL updater for the actualType field of hydra.error.core.LiteralTypeMismatchError literalTypeMismatchErrorWithActualType :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm ErrorCore.LiteralTypeMismatchError literalTypeMismatchErrorWithActualType original newVal =@@ -1321,6 +1414,11 @@         Core.projectionFieldName = (Core.Name "location")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.NestedTermAnnotationError+nestedTermAnnotationErrorNestedTermAnnotationError :: Typed.TypedName ErrorCore.NestedTermAnnotationError+nestedTermAnnotationErrorNestedTermAnnotationError =+    Typed.TypedName (Core.Name "hydra.error.core.NestedTermAnnotationError")+ -- | DSL updater for the location field of hydra.error.core.NestedTermAnnotationError nestedTermAnnotationErrorWithLocation :: Typed.TypedTerm ErrorCore.NestedTermAnnotationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTermAnnotationError nestedTermAnnotationErrorWithLocation original newVal =@@ -1350,6 +1448,11 @@         Core.projectionFieldName = (Core.Name "location")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.NestedTypeAnnotationError+nestedTypeAnnotationErrorNestedTypeAnnotationError :: Typed.TypedName ErrorCore.NestedTypeAnnotationError+nestedTypeAnnotationErrorNestedTypeAnnotationError =+    Typed.TypedName (Core.Name "hydra.error.core.NestedTypeAnnotationError")+ -- | DSL updater for the location field of hydra.error.core.NestedTypeAnnotationError nestedTypeAnnotationErrorWithLocation :: Typed.TypedTerm ErrorCore.NestedTypeAnnotationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTypeAnnotationError nestedTypeAnnotationErrorWithLocation original newVal =@@ -1391,6 +1494,11 @@         Core.projectionFieldName = (Core.Name "location")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.NonComparableMapKeyTypeError+nonComparableMapKeyTypeErrorNonComparableMapKeyTypeError :: Typed.TypedName ErrorCore.NonComparableMapKeyTypeError+nonComparableMapKeyTypeErrorNonComparableMapKeyTypeError =+    Typed.TypedName (Core.Name "hydra.error.core.NonComparableMapKeyTypeError")+ -- | DSL updater for the keyType field of hydra.error.core.NonComparableMapKeyTypeError nonComparableMapKeyTypeErrorWithKeyType :: Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError nonComparableMapKeyTypeErrorWithKeyType original newVal =@@ -1456,6 +1564,11 @@         Core.projectionFieldName = (Core.Name "location")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.NonComparableSetElementTypeError+nonComparableSetElementTypeErrorNonComparableSetElementTypeError :: Typed.TypedName ErrorCore.NonComparableSetElementTypeError+nonComparableSetElementTypeErrorNonComparableSetElementTypeError =+    Typed.TypedName (Core.Name "hydra.error.core.NonComparableSetElementTypeError")+ -- | DSL updater for the elementType field of hydra.error.core.NonComparableSetElementTypeError nonComparableSetElementTypeErrorWithElementType :: Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError nonComparableSetElementTypeErrorWithElementType original newVal =@@ -1512,6 +1625,10 @@         Core.projectionFieldName = (Core.Name "location")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.RedundantWrapUnwrapError+redundantWrapUnwrapErrorRedundantWrapUnwrapError :: Typed.TypedName ErrorCore.RedundantWrapUnwrapError+redundantWrapUnwrapErrorRedundantWrapUnwrapError = Typed.TypedName (Core.Name "hydra.error.core.RedundantWrapUnwrapError")+ -- | DSL accessor for the typeName field of hydra.error.core.RedundantWrapUnwrapError redundantWrapUnwrapErrorTypeName :: Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError -> Typed.TypedTerm Core.Name redundantWrapUnwrapErrorTypeName x =@@ -1586,6 +1703,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.SelfApplicationError+selfApplicationErrorSelfApplicationError :: Typed.TypedName ErrorCore.SelfApplicationError+selfApplicationErrorSelfApplicationError = Typed.TypedName (Core.Name "hydra.error.core.SelfApplicationError")+ -- | DSL updater for the location field of hydra.error.core.SelfApplicationError selfApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.SelfApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.SelfApplicationError selfApplicationErrorWithLocation original newVal =@@ -1651,6 +1772,10 @@         Core.projectionFieldName = (Core.Name "location")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.SingleVariantUnionError+singleVariantUnionErrorSingleVariantUnionError :: Typed.TypedName ErrorCore.SingleVariantUnionError+singleVariantUnionErrorSingleVariantUnionError = Typed.TypedName (Core.Name "hydra.error.core.SingleVariantUnionError")+ -- | DSL updater for the fieldName field of hydra.error.core.SingleVariantUnionError singleVariantUnionErrorWithFieldName :: Typed.TypedTerm ErrorCore.SingleVariantUnionError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.SingleVariantUnionError singleVariantUnionErrorWithFieldName original newVal =@@ -1716,6 +1841,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.TermVariableShadowingError+termVariableShadowingErrorTermVariableShadowingError :: Typed.TypedName ErrorCore.TermVariableShadowingError+termVariableShadowingErrorTermVariableShadowingError =+    Typed.TypedName (Core.Name "hydra.error.core.TermVariableShadowingError")+ -- | DSL updater for the location field of hydra.error.core.TermVariableShadowingError termVariableShadowingErrorWithLocation :: Typed.TypedTerm ErrorCore.TermVariableShadowingError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TermVariableShadowingError termVariableShadowingErrorWithLocation original newVal =@@ -1781,6 +1911,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.TypeVariableShadowingInForallError+typeVariableShadowingInForallErrorTypeVariableShadowingInForallError :: Typed.TypedName ErrorCore.TypeVariableShadowingInForallError+typeVariableShadowingInForallErrorTypeVariableShadowingInForallError =+    Typed.TypedName (Core.Name "hydra.error.core.TypeVariableShadowingInForallError")+ -- | DSL updater for the location field of hydra.error.core.TypeVariableShadowingInForallError typeVariableShadowingInForallErrorWithLocation :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError typeVariableShadowingInForallErrorWithLocation original newVal =@@ -1846,6 +1981,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaErrorTypeVariableShadowingInTypeLambdaError :: Typed.TypedName ErrorCore.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaErrorTypeVariableShadowingInTypeLambdaError =+    Typed.TypedName (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError")+ -- | DSL updater for the location field of hydra.error.core.TypeVariableShadowingInTypeLambdaError typeVariableShadowingInTypeLambdaErrorWithLocation :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError typeVariableShadowingInTypeLambdaErrorWithLocation original newVal =@@ -1911,6 +2051,10 @@         Core.projectionFieldName = (Core.Name "typeName")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedFieldError+undefinedFieldErrorUndefinedFieldError :: Typed.TypedName ErrorCore.UndefinedFieldError+undefinedFieldErrorUndefinedFieldError = Typed.TypedName (Core.Name "hydra.error.core.UndefinedFieldError")+ -- | DSL updater for the fieldName field of hydra.error.core.UndefinedFieldError undefinedFieldErrorWithFieldName :: Typed.TypedTerm ErrorCore.UndefinedFieldError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedFieldError undefinedFieldErrorWithFieldName original newVal =@@ -1976,6 +2120,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTermVariableError+undefinedTermVariableErrorUndefinedTermVariableError :: Typed.TypedName ErrorCore.UndefinedTermVariableError+undefinedTermVariableErrorUndefinedTermVariableError =+    Typed.TypedName (Core.Name "hydra.error.core.UndefinedTermVariableError")+ -- | DSL updater for the location field of hydra.error.core.UndefinedTermVariableError undefinedTermVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTermVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTermVariableError undefinedTermVariableErrorWithLocation original newVal =@@ -2041,6 +2190,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTypeVariableError+undefinedTypeVariableErrorUndefinedTypeVariableError :: Typed.TypedName ErrorCore.UndefinedTypeVariableError+undefinedTypeVariableErrorUndefinedTypeVariableError =+    Typed.TypedName (Core.Name "hydra.error.core.UndefinedTypeVariableError")+ -- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableError undefinedTypeVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableError undefinedTypeVariableErrorWithLocation original newVal =@@ -2106,6 +2260,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeErrorUndefinedTypeVariableInBindingTypeError :: Typed.TypedName ErrorCore.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeErrorUndefinedTypeVariableInBindingTypeError =+    Typed.TypedName (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError")+ -- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInBindingTypeError undefinedTypeVariableInBindingTypeErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError undefinedTypeVariableInBindingTypeErrorWithLocation original newVal =@@ -2171,6 +2330,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainErrorUndefinedTypeVariableInLambdaDomainError :: Typed.TypedName ErrorCore.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainErrorUndefinedTypeVariableInLambdaDomainError =+    Typed.TypedName (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError")+ -- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInLambdaDomainError undefinedTypeVariableInLambdaDomainErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError undefinedTypeVariableInLambdaDomainErrorWithLocation original newVal =@@ -2236,6 +2400,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationErrorUndefinedTypeVariableInTypeApplicationError :: Typed.TypedName ErrorCore.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationErrorUndefinedTypeVariableInTypeApplicationError =+    Typed.TypedName (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError")+ -- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInTypeApplicationError undefinedTypeVariableInTypeApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError undefinedTypeVariableInTypeApplicationErrorWithLocation original newVal =@@ -2301,6 +2470,11 @@         Core.projectionFieldName = (Core.Name "expectedVariant")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UnexpectedTermVariantError+unexpectedTermVariantErrorUnexpectedTermVariantError :: Typed.TypedName ErrorCore.UnexpectedTermVariantError+unexpectedTermVariantErrorUnexpectedTermVariantError =+    Typed.TypedName (Core.Name "hydra.error.core.UnexpectedTermVariantError")+ -- | DSL updater for the actualTerm field of hydra.error.core.UnexpectedTermVariantError unexpectedTermVariantErrorWithActualTerm :: Typed.TypedTerm ErrorCore.UnexpectedTermVariantError -> Typed.TypedTerm Core.Term -> Typed.TypedTerm ErrorCore.UnexpectedTermVariantError unexpectedTermVariantErrorWithActualTerm original newVal =@@ -2366,6 +2540,11 @@         Core.projectionFieldName = (Core.Name "expectedVariant")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UnexpectedTypeVariantError+unexpectedTypeVariantErrorUnexpectedTypeVariantError :: Typed.TypedName ErrorCore.UnexpectedTypeVariantError+unexpectedTypeVariantErrorUnexpectedTypeVariantError =+    Typed.TypedName (Core.Name "hydra.error.core.UnexpectedTypeVariantError")+ -- | DSL updater for the actualType field of hydra.error.core.UnexpectedTypeVariantError unexpectedTypeVariantErrorWithActualType :: Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError unexpectedTypeVariantErrorWithActualType original newVal =@@ -2431,6 +2610,11 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UnknownPrimitiveNameError+unknownPrimitiveNameErrorUnknownPrimitiveNameError :: Typed.TypedName ErrorCore.UnknownPrimitiveNameError+unknownPrimitiveNameErrorUnknownPrimitiveNameError =+    Typed.TypedName (Core.Name "hydra.error.core.UnknownPrimitiveNameError")+ -- | DSL updater for the location field of hydra.error.core.UnknownPrimitiveNameError unknownPrimitiveNameErrorWithLocation :: Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError unknownPrimitiveNameErrorWithLocation original newVal =@@ -2484,6 +2668,11 @@         Core.projectionFieldName = (Core.Name "location")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationErrorUnnecessaryIdentityApplicationError :: Typed.TypedName ErrorCore.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationErrorUnnecessaryIdentityApplicationError =+    Typed.TypedName (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError")+ -- | DSL updater for the location field of hydra.error.core.UnnecessaryIdentityApplicationError unnecessaryIdentityApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError unnecessaryIdentityApplicationErrorWithLocation original newVal =@@ -2525,6 +2714,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UntypedTermVariableError+untypedTermVariableErrorUntypedTermVariableError :: Typed.TypedName ErrorCore.UntypedTermVariableError+untypedTermVariableErrorUntypedTermVariableError = Typed.TypedName (Core.Name "hydra.error.core.UntypedTermVariableError")+ -- | DSL updater for the location field of hydra.error.core.UntypedTermVariableError untypedTermVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UntypedTermVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UntypedTermVariableError untypedTermVariableErrorWithLocation original newVal =@@ -2577,6 +2770,11 @@         Core.projectionTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"),         Core.projectionFieldName = (Core.Name "location")})),       Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.error.core.VoidInNonBottomPositionError+voidInNonBottomPositionErrorVoidInNonBottomPositionError :: Typed.TypedName ErrorCore.VoidInNonBottomPositionError+voidInNonBottomPositionErrorVoidInNonBottomPositionError =+    Typed.TypedName (Core.Name "hydra.error.core.VoidInNonBottomPositionError")  -- | DSL updater for the location field of hydra.error.core.VoidInNonBottomPositionError voidInNonBottomPositionErrorWithLocation :: Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError

@@ -5,7 +5,9 @@ module Hydra.Dsl.Error.File where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Error.File as DecodeErrorFile import qualified Hydra.Dsl.File as DslFile+import qualified Hydra.Encode.Error.File as EncodeErrorFile import qualified Hydra.Error.File as ErrorFile import qualified Hydra.File as File import qualified Hydra.Typed as Typed@@ -20,6 +22,10 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "alreadyExists"),         Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.error.file.FileError+fileErrorFileError :: Typed.TypedName ErrorFile.FileError+fileErrorFileError = Typed.TypedName (Core.Name "hydra.error.file.FileError")  -- | DSL injection for the invalidPath variant of hydra.error.file.FileError fileErrorInvalidPath :: Typed.TypedTerm String -> Typed.TypedTerm ErrorFile.FileError

@@ -5,9 +5,11 @@ module Hydra.Dsl.Error.Packaging where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Error.Packaging as DecodeErrorPackaging import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Packaging as DslPackaging import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Encode.Error.Packaging as EncodeErrorPackaging import qualified Hydra.Error.Packaging as ErrorPackaging import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed@@ -28,6 +30,11 @@           Core.fieldName = (Core.Name "second"),           Core.fieldTerm = (Typed.unTypedTerm second)}]})) +-- | DSL name token for hydra.error.packaging.ConflictingModuleNameError+conflictingModuleNameErrorConflictingModuleNameError :: Typed.TypedName ErrorPackaging.ConflictingModuleNameError+conflictingModuleNameErrorConflictingModuleNameError =+    Typed.TypedName (Core.Name "hydra.error.packaging.ConflictingModuleNameError")+ -- | DSL accessor for the first field of hydra.error.packaging.ConflictingModuleNameError conflictingModuleNameErrorFirst :: Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError -> Typed.TypedTerm Packaging.ModuleName conflictingModuleNameErrorFirst x =@@ -108,6 +115,11 @@         Core.projectionFieldName = (Core.Name "conflictingName")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorConflictingVariantNameError :: Typed.TypedName ErrorPackaging.ConflictingVariantNameError+conflictingVariantNameErrorConflictingVariantNameError =+    Typed.TypedName (Core.Name "hydra.error.packaging.ConflictingVariantNameError")+ -- | DSL accessor for the moduleName field of hydra.error.packaging.ConflictingVariantNameError conflictingVariantNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Packaging.ModuleName conflictingVariantNameErrorModuleName x =@@ -272,6 +284,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.packaging.DefinitionNotInModuleNameError+definitionNotInModuleNameErrorDefinitionNotInModuleNameError :: Typed.TypedName ErrorPackaging.DefinitionNotInModuleNameError+definitionNotInModuleNameErrorDefinitionNotInModuleNameError =+    Typed.TypedName (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError")+ -- | DSL accessor for the moduleName field of hydra.error.packaging.DefinitionNotInModuleNameError definitionNotInModuleNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError -> Typed.TypedTerm Packaging.ModuleName definitionNotInModuleNameErrorModuleName x =@@ -340,6 +357,11 @@           Core.fieldName = (Core.Name "followingName"),           Core.fieldTerm = (Typed.unTypedTerm followingName)}]})) +-- | DSL name token for hydra.error.packaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorDefinitionsOutOfOrderError :: Typed.TypedName ErrorPackaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorDefinitionsOutOfOrderError =+    Typed.TypedName (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError")+ -- | DSL accessor for the followingName field of hydra.error.packaging.DefinitionsOutOfOrderError definitionsOutOfOrderErrorFollowingName :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm Core.Name definitionsOutOfOrderErrorFollowingName x =@@ -452,6 +474,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.packaging.DuplicateDefinitionNameError+duplicateDefinitionNameErrorDuplicateDefinitionNameError :: Typed.TypedName ErrorPackaging.DuplicateDefinitionNameError+duplicateDefinitionNameErrorDuplicateDefinitionNameError =+    Typed.TypedName (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError")+ -- | DSL accessor for the moduleName field of hydra.error.packaging.DuplicateDefinitionNameError duplicateDefinitionNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError -> Typed.TypedTerm Packaging.ModuleName duplicateDefinitionNameErrorModuleName x =@@ -514,6 +541,11 @@           Core.fieldName = (Core.Name "moduleName"),           Core.fieldTerm = (Typed.unTypedTerm moduleName)}]})) +-- | DSL name token for hydra.error.packaging.DuplicateModuleNameError+duplicateModuleNameErrorDuplicateModuleNameError :: Typed.TypedName ErrorPackaging.DuplicateModuleNameError+duplicateModuleNameErrorDuplicateModuleNameError =+    Typed.TypedName (Core.Name "hydra.error.packaging.DuplicateModuleNameError")+ -- | DSL accessor for the moduleName field of hydra.error.packaging.DuplicateModuleNameError duplicateModuleNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateModuleNameError -> Typed.TypedTerm Packaging.ModuleName duplicateModuleNameErrorModuleName x =@@ -558,6 +590,11 @@         Core.projectionFieldName = (Core.Name "expectedConvention")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.packaging.InvalidDefinitionNameError+invalidDefinitionNameErrorInvalidDefinitionNameError :: Typed.TypedName ErrorPackaging.InvalidDefinitionNameError+invalidDefinitionNameErrorInvalidDefinitionNameError =+    Typed.TypedName (Core.Name "hydra.error.packaging.InvalidDefinitionNameError")+ -- | DSL accessor for the moduleName field of hydra.error.packaging.InvalidDefinitionNameError invalidDefinitionNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm Packaging.ModuleName invalidDefinitionNameErrorModuleName x =@@ -693,6 +730,10 @@         Core.fieldName = (Core.Name "invalidDefinitionName"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.error.packaging.InvalidModuleError+invalidModuleErrorInvalidModuleError :: Typed.TypedName ErrorPackaging.InvalidModuleError+invalidModuleErrorInvalidModuleError = Typed.TypedName (Core.Name "hydra.error.packaging.InvalidModuleError")+ -- | DSL injection for the invalidModuleNameConvention variant of hydra.error.packaging.InvalidModuleError invalidModuleErrorInvalidModuleNameConvention :: Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError invalidModuleErrorInvalidModuleNameConvention x =@@ -721,6 +762,11 @@           Core.fieldName = (Core.Name "moduleName"),           Core.fieldTerm = (Typed.unTypedTerm moduleName)}]})) +-- | DSL name token for hydra.error.packaging.InvalidModuleNameConventionError+invalidModuleNameConventionErrorInvalidModuleNameConventionError :: Typed.TypedName ErrorPackaging.InvalidModuleNameConventionError+invalidModuleNameConventionErrorInvalidModuleNameConventionError =+    Typed.TypedName (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError")+ -- | DSL accessor for the moduleName field of hydra.error.packaging.InvalidModuleNameConventionError invalidModuleNameConventionErrorModuleName :: Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError -> Typed.TypedTerm Packaging.ModuleName invalidModuleNameConventionErrorModuleName x =@@ -767,6 +813,10 @@         Core.fieldName = (Core.Name "invalidModule"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.error.packaging.InvalidPackageError+invalidPackageErrorInvalidPackageError :: Typed.TypedName ErrorPackaging.InvalidPackageError+invalidPackageErrorInvalidPackageError = Typed.TypedName (Core.Name "hydra.error.packaging.InvalidPackageError")+ -- | DSL injection for the invalidPackageName variant of hydra.error.packaging.InvalidPackageError invalidPackageErrorInvalidPackageName :: Typed.TypedTerm ErrorPackaging.InvalidPackageNameError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError invalidPackageErrorInvalidPackageName x =@@ -776,6 +826,15 @@         Core.fieldName = (Core.Name "invalidPackageName"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL injection for the undeclaredDependency variant of hydra.error.packaging.InvalidPackageError+invalidPackageErrorUndeclaredDependency :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError+invalidPackageErrorUndeclaredDependency x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undeclaredDependency"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+ -- | DSL constructor for hydra.error.packaging.InvalidPackageNameError invalidPackageNameError :: Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm ErrorPackaging.InvalidPackageNameError invalidPackageNameError packageName =@@ -786,6 +845,11 @@           Core.fieldName = (Core.Name "packageName"),           Core.fieldTerm = (Typed.unTypedTerm packageName)}]})) +-- | DSL name token for hydra.error.packaging.InvalidPackageNameError+invalidPackageNameErrorInvalidPackageNameError :: Typed.TypedName ErrorPackaging.InvalidPackageNameError+invalidPackageNameErrorInvalidPackageNameError =+    Typed.TypedName (Core.Name "hydra.error.packaging.InvalidPackageNameError")+ -- | DSL accessor for the packageName field of hydra.error.packaging.InvalidPackageNameError invalidPackageNameErrorPackageName :: Typed.TypedTerm ErrorPackaging.InvalidPackageNameError -> Typed.TypedTerm Packaging.PackageName invalidPackageNameErrorPackageName x =@@ -818,6 +882,11 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.packaging.MissingDocumentationError+missingDocumentationErrorMissingDocumentationError :: Typed.TypedName ErrorPackaging.MissingDocumentationError+missingDocumentationErrorMissingDocumentationError =+    Typed.TypedName (Core.Name "hydra.error.packaging.MissingDocumentationError")+ -- | DSL accessor for the moduleName field of hydra.error.packaging.MissingDocumentationError missingDocumentationErrorModuleName :: Typed.TypedTerm ErrorPackaging.MissingDocumentationError -> Typed.TypedTerm Packaging.ModuleName missingDocumentationErrorModuleName x =@@ -869,3 +938,123 @@         Core.Field {           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError+undeclaredDependencyError moduleName referencedName owningModuleName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "referencedName"),+          Core.fieldTerm = (Typed.unTypedTerm referencedName)},+        Core.Field {+          Core.fieldName = (Core.Name "owningModuleName"),+          Core.fieldTerm = (Typed.unTypedTerm owningModuleName)}]}))++-- | DSL accessor for the moduleName field of hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyErrorModuleName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Packaging.ModuleName+undeclaredDependencyErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the owningModuleName field of hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyErrorOwningModuleName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Packaging.ModuleName+undeclaredDependencyErrorOwningModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+        Core.projectionFieldName = (Core.Name "owningModuleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the referencedName field of hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyErrorReferencedName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Core.Name+undeclaredDependencyErrorReferencedName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+        Core.projectionFieldName = (Core.Name "referencedName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyErrorUndeclaredDependencyError :: Typed.TypedName ErrorPackaging.UndeclaredDependencyError+undeclaredDependencyErrorUndeclaredDependencyError =+    Typed.TypedName (Core.Name "hydra.error.packaging.UndeclaredDependencyError")++-- | DSL updater for the moduleName field of hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError+undeclaredDependencyErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "referencedName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+              Core.projectionFieldName = (Core.Name "referencedName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "owningModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+              Core.projectionFieldName = (Core.Name "owningModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the owningModuleName field of hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyErrorWithOwningModuleName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError+undeclaredDependencyErrorWithOwningModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "referencedName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+              Core.projectionFieldName = (Core.Name "referencedName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "owningModuleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the referencedName field of hydra.error.packaging.UndeclaredDependencyError+undeclaredDependencyErrorWithReferencedName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError+undeclaredDependencyErrorWithReferencedName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "referencedName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "owningModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"),+              Core.projectionFieldName = (Core.Name "owningModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

@@ -5,7 +5,9 @@ module Hydra.Dsl.Error.System where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Error.System as DecodeErrorSystem import qualified Hydra.Dsl.File as DslFile+import qualified Hydra.Encode.Error.System as EncodeErrorSystem import qualified Hydra.Error.System as System import qualified Hydra.File as File import qualified Hydra.Typed as Typed@@ -56,3 +58,7 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "permissionDenied"),         Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.error.system.SystemError+systemErrorSystemError :: Typed.TypedName System.SystemError+systemErrorSystemError = Typed.TypedName (Core.Name "hydra.error.system.SystemError")

@@ -5,12 +5,14 @@ module Hydra.Dsl.Errors where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Errors as DecodeErrors import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Error.Checking as ErrorChecking import qualified Hydra.Dsl.Error.Core as DslErrorCore import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Typing as DslTyping import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Encode.Errors as EncodeErrors import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore import qualified Hydra.Errors as Errors@@ -28,6 +30,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.DecodingError+decodingErrorDecodingError :: Typed.TypedName Errors.DecodingError+decodingErrorDecodingError = Typed.TypedName (Core.Name "hydra.errors.DecodingError")+ -- | DSL injection for the checking variant of hydra.errors.Error errorChecking :: Typed.TypedTerm Checking.CheckingError -> Typed.TypedTerm Errors.Error errorChecking x =@@ -64,6 +70,10 @@         Core.fieldName = (Core.Name "duplicateField"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.errors.Error+errorError :: Typed.TypedName Errors.Error+errorError = Typed.TypedName (Core.Name "hydra.errors.Error")+ -- | DSL injection for the extraction variant of hydra.errors.Error errorExtraction :: Typed.TypedTerm Errors.ExtractionError -> Typed.TypedTerm Errors.Error errorExtraction x =@@ -172,6 +182,10 @@         Core.fieldName = (Core.Name "emptyList"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.errors.ExtractionError+extractionErrorExtractionError :: Typed.TypedName Errors.ExtractionError+extractionErrorExtractionError = Typed.TypedName (Core.Name "hydra.errors.ExtractionError")+ -- | DSL injection for the multipleBindings variant of hydra.errors.ExtractionError extractionErrorMultipleBindings :: Typed.TypedTerm Errors.MultipleBindingsError -> Typed.TypedTerm Errors.ExtractionError extractionErrorMultipleBindings x =@@ -235,6 +249,10 @@         Core.fieldName = (Core.Name "checking"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.errors.InferenceError+inferenceErrorInferenceError :: Typed.TypedName Errors.InferenceError+inferenceErrorInferenceError = Typed.TypedName (Core.Name "hydra.errors.InferenceError")+ -- | DSL injection for the other variant of hydra.errors.InferenceError inferenceErrorOther :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm Errors.InferenceError inferenceErrorOther x =@@ -263,6 +281,10 @@           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.errors.MultipleBindingsError+multipleBindingsErrorMultipleBindingsError :: Typed.TypedName Errors.MultipleBindingsError+multipleBindingsErrorMultipleBindingsError = Typed.TypedName (Core.Name "hydra.errors.MultipleBindingsError")+ -- | DSL accessor for the name field of hydra.errors.MultipleBindingsError multipleBindingsErrorName :: Typed.TypedTerm Errors.MultipleBindingsError -> Typed.TypedTerm Core.Name multipleBindingsErrorName x =@@ -301,6 +323,10 @@         Core.projectionFieldName = (Core.Name "fieldName")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.MultipleFieldsError+multipleFieldsErrorMultipleFieldsError :: Typed.TypedName Errors.MultipleFieldsError+multipleFieldsErrorMultipleFieldsError = Typed.TypedName (Core.Name "hydra.errors.MultipleFieldsError")+ -- | DSL updater for the fieldName field of hydra.errors.MultipleFieldsError multipleFieldsErrorWithFieldName :: Typed.TypedTerm Errors.MultipleFieldsError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.MultipleFieldsError multipleFieldsErrorWithFieldName original newVal =@@ -330,6 +356,10 @@         Core.projectionFieldName = (Core.Name "fieldName")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.NoMatchingFieldError+noMatchingFieldErrorNoMatchingFieldError :: Typed.TypedName Errors.NoMatchingFieldError+noMatchingFieldErrorNoMatchingFieldError = Typed.TypedName (Core.Name "hydra.errors.NoMatchingFieldError")+ -- | DSL updater for the fieldName field of hydra.errors.NoMatchingFieldError noMatchingFieldErrorWithFieldName :: Typed.TypedTerm Errors.NoMatchingFieldError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoMatchingFieldError noMatchingFieldErrorWithFieldName original newVal =@@ -359,6 +389,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.NoSuchBindingError+noSuchBindingErrorNoSuchBindingError :: Typed.TypedName Errors.NoSuchBindingError+noSuchBindingErrorNoSuchBindingError = Typed.TypedName (Core.Name "hydra.errors.NoSuchBindingError")+ -- | DSL updater for the name field of hydra.errors.NoSuchBindingError noSuchBindingErrorWithName :: Typed.TypedTerm Errors.NoSuchBindingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoSuchBindingError noSuchBindingErrorWithName original newVal =@@ -388,6 +422,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.NoSuchPrimitiveError+noSuchPrimitiveErrorNoSuchPrimitiveError :: Typed.TypedName Errors.NoSuchPrimitiveError+noSuchPrimitiveErrorNoSuchPrimitiveError = Typed.TypedName (Core.Name "hydra.errors.NoSuchPrimitiveError")+ -- | DSL updater for the name field of hydra.errors.NoSuchPrimitiveError noSuchPrimitiveErrorWithName :: Typed.TypedTerm Errors.NoSuchPrimitiveError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoSuchPrimitiveError noSuchPrimitiveErrorWithName original newVal =@@ -405,6 +443,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.OtherError+otherErrorOtherError :: Typed.TypedName Errors.OtherError+otherErrorOtherError = Typed.TypedName (Core.Name "hydra.errors.OtherError")+ -- | DSL constructor for hydra.errors.OtherInferenceError otherInferenceError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm String -> Typed.TypedTerm Errors.OtherInferenceError otherInferenceError path message =@@ -427,6 +469,10 @@         Core.projectionFieldName = (Core.Name "message")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.OtherInferenceError+otherInferenceErrorOtherInferenceError :: Typed.TypedName Errors.OtherInferenceError+otherInferenceErrorOtherInferenceError = Typed.TypedName (Core.Name "hydra.errors.OtherInferenceError")+ -- | DSL accessor for the path field of hydra.errors.OtherInferenceError otherInferenceErrorPath :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm Paths.SubtermPath otherInferenceErrorPath x =@@ -477,6 +523,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherResolutionError"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.OtherResolutionError+otherResolutionErrorOtherResolutionError :: Typed.TypedName Errors.OtherResolutionError+otherResolutionErrorOtherResolutionError = Typed.TypedName (Core.Name "hydra.errors.OtherResolutionError")+ -- | DSL injection for the noMatchingField variant of hydra.errors.ResolutionError resolutionErrorNoMatchingField :: Typed.TypedTerm Errors.NoMatchingFieldError -> Typed.TypedTerm Errors.ResolutionError resolutionErrorNoMatchingField x =@@ -513,6 +563,10 @@         Core.fieldName = (Core.Name "other"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.errors.ResolutionError+resolutionErrorResolutionError :: Typed.TypedName Errors.ResolutionError+resolutionErrorResolutionError = Typed.TypedName (Core.Name "hydra.errors.ResolutionError")+ -- | DSL injection for the unexpectedShape variant of hydra.errors.ResolutionError resolutionErrorUnexpectedShape :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm Errors.ResolutionError resolutionErrorUnexpectedShape x =@@ -574,6 +628,10 @@         Core.projectionFieldName = (Core.Name "expected")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.UnexpectedShapeError+unexpectedShapeErrorUnexpectedShapeError :: Typed.TypedName Errors.UnexpectedShapeError+unexpectedShapeErrorUnexpectedShapeError = Typed.TypedName (Core.Name "hydra.errors.UnexpectedShapeError")+ -- | DSL updater for the actual field of hydra.errors.UnexpectedShapeError unexpectedShapeErrorWithActual :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm String -> Typed.TypedTerm Errors.UnexpectedShapeError unexpectedShapeErrorWithActual original newVal =@@ -651,6 +709,10 @@         Core.projectionFieldName = (Core.Name "rightType")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.UnificationError+unificationErrorUnificationError :: Typed.TypedName Errors.UnificationError+unificationErrorUnificationError = Typed.TypedName (Core.Name "hydra.errors.UnificationError")+ -- | DSL updater for the leftType field of hydra.errors.UnificationError unificationErrorWithLeftType :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Errors.UnificationError unificationErrorWithLeftType original newVal =@@ -753,6 +815,10 @@         Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),         Core.projectionFieldName = (Core.Name "path")})),       Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.errors.UnificationInferenceError+unificationInferenceErrorUnificationInferenceError :: Typed.TypedName Errors.UnificationInferenceError+unificationInferenceErrorUnificationInferenceError = Typed.TypedName (Core.Name "hydra.errors.UnificationInferenceError")  -- | DSL updater for the cause field of hydra.errors.UnificationInferenceError unificationInferenceErrorWithCause :: Typed.TypedTerm Errors.UnificationInferenceError -> Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Errors.UnificationInferenceError

@@ -0,0 +1,165 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.extract.json++module Hydra.Dsl.Extract.Json 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.Json.Writer as JsonWriter+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.Extract.Json as Json+import qualified Hydra.File as File+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Json.Writer as Writer+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.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+import qualified Data.Map as M++-- | DSL reference to hydra.extract.json.expectArray+expectArray :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String [Model.Value])+expectArray arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.expectArray")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.extract.json.expectNumber+expectNumber :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Sci.Scientific)+expectNumber arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.expectNumber")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.extract.json.expectObject+expectObject :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String (M.Map String Model.Value))+expectObject arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.expectObject")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.extract.json.expectString+expectString :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String String)+expectString arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.expectString")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.extract.json.opt+opt :: Ord t0 => (Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map t0 t1) -> Typed.TypedTerm (Maybe t1))+opt arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.opt")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.extract.json.optArray+optArray :: Ord t0 => (Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map t0 Model.Value) -> Typed.TypedTerm (Either String (Maybe [Model.Value])))+optArray arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.optArray")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.extract.json.optString+optString :: Ord t0 => (Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map t0 Model.Value) -> Typed.TypedTerm (Either String (Maybe String)))+optString arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.optString")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.extract.json.require+require :: Typed.TypedTerm String -> Typed.TypedTerm (M.Map String t0) -> Typed.TypedTerm (Either String t0)+require arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.require")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.extract.json.requireArray+requireArray :: Typed.TypedTerm String -> Typed.TypedTerm (M.Map String Model.Value) -> Typed.TypedTerm (Either String [Model.Value])+requireArray arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.requireArray")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.extract.json.requireNumber+requireNumber :: Typed.TypedTerm String -> Typed.TypedTerm (M.Map String Model.Value) -> Typed.TypedTerm (Either String Sci.Scientific)+requireNumber arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.requireNumber")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.extract.json.requireString+requireString :: Typed.TypedTerm String -> Typed.TypedTerm (M.Map String Model.Value) -> Typed.TypedTerm (Either String String)+requireString arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.requireString")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.extract.json.showValue+showValue :: Typed.TypedTerm Model.Value -> Typed.TypedTerm String+showValue arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.showValue")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -5,8 +5,10 @@ module Hydra.Dsl.File where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.File as DecodeFile import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Time as DslTime+import qualified Hydra.Encode.File as EncodeFile import qualified Hydra.File as File import qualified Hydra.Time as Time import qualified Hydra.Typed as Typed@@ -21,6 +23,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.file.FileExtension"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.file.FileExtension+fileExtensionFileExtension :: Typed.TypedName File.FileExtension+fileExtensionFileExtension = Typed.TypedName (Core.Name "hydra.file.FileExtension")+ -- | DSL constructor for the hydra.file.FilePath wrapper filePath :: Typed.TypedTerm String -> Typed.TypedTerm File.FilePath filePath x =@@ -28,6 +34,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.file.FilePath"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.file.FilePath+filePathFilePath :: Typed.TypedName File.FilePath+filePathFilePath = Typed.TypedName (Core.Name "hydra.file.FilePath")+ -- | DSL constructor for hydra.file.FileStatus fileStatus :: Typed.TypedTerm File.FileType -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Time.Timespec -> Typed.TypedTerm (Maybe Time.Timespec) -> Typed.TypedTerm (Maybe Time.Timespec) -> Typed.TypedTerm File.FileStatus fileStatus fileType size modificationTime accessTime statusChangeTime =@@ -59,6 +69,10 @@         Core.projectionFieldName = (Core.Name "accessTime")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.file.FileStatus+fileStatusFileStatus :: Typed.TypedName File.FileStatus+fileStatusFileStatus = Typed.TypedName (Core.Name "hydra.file.FileStatus")+ -- | DSL accessor for the fileType field of hydra.file.FileStatus fileStatusFileType :: Typed.TypedTerm File.FileStatus -> Typed.TypedTerm File.FileType fileStatusFileType x =@@ -320,6 +334,10 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "fifo"),         Core.fieldTerm = Core.TermUnit}}))++-- | DSL name token for hydra.file.FileType+fileTypeFileType :: Typed.TypedName File.FileType+fileTypeFileType = Typed.TypedName (Core.Name "hydra.file.FileType")  -- | DSL injection for the link variant of hydra.file.FileType fileTypeLink :: Typed.TypedTerm File.FileType

@@ -0,0 +1,205 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.formatting++module Hydra.Dsl.Formatting 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.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.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+import qualified Data.Set as S++-- | DSL reference to hydra.formatting.capitalize+capitalize :: Typed.TypedTerm String -> Typed.TypedTerm String+capitalize arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.capitalize")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.convertCase+convertCase :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm String -> Typed.TypedTerm String+convertCase 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.formatting.convertCase")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.formatting.convertCaseCamelOrUnderscoreToLowerSnake+convertCaseCamelOrUnderscoreToLowerSnake :: Typed.TypedTerm String -> Typed.TypedTerm String+convertCaseCamelOrUnderscoreToLowerSnake arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCaseCamelOrUnderscoreToLowerSnake")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.convertCaseCamelToLowerSnake+convertCaseCamelToLowerSnake :: Typed.TypedTerm String -> Typed.TypedTerm String+convertCaseCamelToLowerSnake arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCaseCamelToLowerSnake")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.convertCaseCamelToUpperSnake+convertCaseCamelToUpperSnake :: Typed.TypedTerm String -> Typed.TypedTerm String+convertCaseCamelToUpperSnake arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCaseCamelToUpperSnake")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.convertCasePascalToUpperSnake+convertCasePascalToUpperSnake :: Typed.TypedTerm String -> Typed.TypedTerm String+convertCasePascalToUpperSnake arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCasePascalToUpperSnake")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.decapitalize+decapitalize :: Typed.TypedTerm String -> Typed.TypedTerm String+decapitalize arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.decapitalize")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.escapeWithUnderscore+escapeWithUnderscore :: Typed.TypedTerm (S.Set String) -> Typed.TypedTerm String -> Typed.TypedTerm String+escapeWithUnderscore arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.escapeWithUnderscore")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.formatting.indentLines+indentLines :: Typed.TypedTerm String -> Typed.TypedTerm String+indentLines arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.indentLines")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.javaStyleComment+javaStyleComment :: Typed.TypedTerm String -> Typed.TypedTerm String+javaStyleComment arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.javaStyleComment")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.mapFirstLetter+mapFirstLetter :: Typed.TypedTerm (String -> String) -> Typed.TypedTerm String -> Typed.TypedTerm String+mapFirstLetter arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.mapFirstLetter")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.formatting.nonAlnumToUnderscores+nonAlnumToUnderscores :: Typed.TypedTerm String -> Typed.TypedTerm String+nonAlnumToUnderscores arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.nonAlnumToUnderscores")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.normalizeComment+normalizeComment :: Typed.TypedTerm String -> Typed.TypedTerm String+normalizeComment arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.normalizeComment")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.sanitizeWithUnderscores+sanitizeWithUnderscores :: Typed.TypedTerm (S.Set String) -> Typed.TypedTerm String -> Typed.TypedTerm String+sanitizeWithUnderscores arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.sanitizeWithUnderscores")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.formatting.showList+showList :: Typed.TypedTerm (t0 -> String) -> Typed.TypedTerm [t0] -> Typed.TypedTerm String+showList arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.showList")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.formatting.stripLeadingAndTrailingWhitespace+stripLeadingAndTrailingWhitespace :: Typed.TypedTerm String -> Typed.TypedTerm String+stripLeadingAndTrailingWhitespace arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.stripLeadingAndTrailingWhitespace")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.withCharacterAliases+withCharacterAliases :: Typed.TypedTerm String -> Typed.TypedTerm String+withCharacterAliases arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.withCharacterAliases")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.wrapLine+wrapLine :: Typed.TypedTerm Int -> Typed.TypedTerm String -> Typed.TypedTerm String+wrapLine arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.wrapLine")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))

@@ -19,6 +19,20 @@ import qualified Data.Map as M import qualified Data.Set as S +-- | DSL composition builder for the decoder of hydra.graph.TermCoder+decodeTermCoder :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Graph.TermCoder a))+decodeTermCoder a =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.graph.termCoder")),+      Core.applicationArgument = (Typed.unTypedTerm a)}))++-- | DSL composition builder for the encoder of hydra.graph.TermCoder+encodeTermCoder :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Graph.TermCoder a -> Core.Term)+encodeTermCoder a =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.graph.termCoder")),+      Core.applicationArgument = (Typed.unTypedTerm a)}))+ -- | DSL constructor for hydra.graph.Graph graph :: Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm (M.Map Core.Name Core.TypeVariableConstraints) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Graph.Primitive) -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Graph.Graph graph boundTerms boundTypes classConstraints lambdaVariables metadata primitives schemaTypes typeVariables =@@ -77,6 +91,10 @@         Core.projectionFieldName = (Core.Name "classConstraints")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.graph.Graph+graphGraph :: Typed.TypedName Graph.Graph+graphGraph = Typed.TypedName (Core.Name "hydra.graph.Graph")+ -- | DSL accessor for the lambdaVariables field of hydra.graph.Graph graphLambdaVariables :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (S.Set Core.Name) graphLambdaVariables x =@@ -610,6 +628,10 @@           Core.fieldName = (Core.Name "primitives"),           Core.fieldTerm = (Typed.unTypedTerm primitives)}]})) +-- | DSL name token for hydra.graph.Library+libraryLibrary :: Typed.TypedName Graph.Library+libraryLibrary = Typed.TypedName (Core.Name "hydra.graph.Library")+ -- | DSL accessor for the name field of hydra.graph.Library libraryName :: Typed.TypedTerm Graph.Library -> Typed.TypedTerm Packaging.ModuleName libraryName x =@@ -740,6 +762,10 @@         Core.projectionFieldName = (Core.Name "implementation")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.graph.Primitive+primitivePrimitive :: Typed.TypedName Graph.Primitive+primitivePrimitive = Typed.TypedName (Core.Name "hydra.graph.Primitive")+ -- | DSL updater for the definition field of hydra.graph.Primitive primitiveWithDefinition :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Graph.Primitive primitiveWithDefinition original newVal =@@ -807,6 +833,10 @@         Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),         Core.projectionFieldName = (Core.Name "encode")})),       Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.graph.TermCoder+termCoderTermCoder :: Typed.TypedName (Graph.TermCoder a)+termCoderTermCoder = Typed.TypedName (Core.Name "hydra.graph.TermCoder")  -- | DSL accessor for the type field of hydra.graph.TermCoder termCoderType :: Typed.TypedTerm (Graph.TermCoder a) -> Typed.TypedTerm Core.Type

@@ -0,0 +1,37 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.json.bootstrap++module Hydra.Dsl.Json.Bootstrap where++import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Error.Checking as ErrorChecking+import qualified Hydra.Dsl.Error.Core as DslErrorCore+import qualified Hydra.Dsl.Errors as DslErrors+import qualified Hydra.Dsl.Graph as DslGraph+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Bootstrap as Bootstrap+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Paths as Paths+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M++-- | DSL reference to hydra.json.bootstrap.typesByName+typesByName :: Typed.TypedTerm (M.Map Core.Name Core.Type)+typesByName = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.bootstrap.typesByName"))

@@ -0,0 +1,153 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.json.decode++module Hydra.Dsl.Json.Decode 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.Strip as DslStrip+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.Extract.Core as ExtractCore+import qualified Hydra.File as File+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Decode as Decode+import qualified Hydra.Json.Model as Model+import qualified Hydra.Literals as Literals+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Strip as Strip+import qualified Hydra.Substitution as Substitution+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+import qualified Data.Map as M++-- | DSL reference to hydra.json.decode.decodeFloat+decodeFloat :: Typed.TypedTerm Core.FloatType -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Core.Term)+decodeFloat arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.decodeFloat")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.json.decode.decodeInteger+decodeInteger :: Typed.TypedTerm Core.IntegerType -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Core.Term)+decodeInteger arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.decodeInteger")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.json.decode.decodeLiteral+decodeLiteral :: Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Core.Term)+decodeLiteral arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.decodeLiteral")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.json.decode.expectArray+expectArray :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String [Model.Value])+expectArray arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.expectArray")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.decode.expectNumber+expectNumber :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Sci.Scientific)+expectNumber arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.expectNumber")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.decode.expectObject+expectObject :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String (M.Map String Model.Value))+expectObject arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.expectObject")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.decode.expectString+expectString :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String String)+expectString arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.expectString")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.decode.fromJson+fromJson :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Core.Term)+fromJson 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.json.decode.fromJson")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.json.decode.parseSpecialFloat+parseSpecialFloat :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Double)+parseSpecialFloat arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.parseSpecialFloat")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.decode.parseSpecialFloat32+parseSpecialFloat32 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Float)+parseSpecialFloat32 arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.parseSpecialFloat32")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -0,0 +1,117 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.json.decoding++module Hydra.Dsl.Json.Decoding 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.Decoding as Decoding+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.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+import qualified Data.Map as M++-- | DSL reference to hydra.json.decoding.decodeArray+decodeArray :: Typed.TypedTerm (Model.Value -> Either String t0) -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String [t0])+decodeArray arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decoding.decodeArray")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.json.decoding.decodeBoolean+decodeBoolean :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Bool)+decodeBoolean arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decoding.decodeBoolean")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.decoding.decodeField+decodeField :: Typed.TypedTerm (t0 -> Either String t1) -> Typed.TypedTerm String -> Typed.TypedTerm (M.Map String t0) -> Typed.TypedTerm (Either String t1)+decodeField 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.json.decoding.decodeField")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.json.decoding.decodeObject+decodeObject :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String (M.Map String Model.Value))+decodeObject arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decoding.decodeObject")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.decoding.decodeOptionalField+decodeOptionalField :: Ord t3 => (Typed.TypedTerm (t0 -> Either t1 t2) -> Typed.TypedTerm t3 -> Typed.TypedTerm (M.Map t3 t0) -> Typed.TypedTerm (Either t1 (Maybe t2)))+decodeOptionalField 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.json.decoding.decodeOptionalField")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.json.decoding.decodeString+decodeString :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String String)+decodeString arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decoding.decodeString")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -0,0 +1,119 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.json.encode++module Hydra.Dsl.Json.Encode 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.Strip as DslStrip+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.Extract.Core as ExtractCore+import qualified Hydra.File as File+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Encode as Encode+import qualified Hydra.Json.Model as Model+import qualified Hydra.Literals as Literals+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Strip as Strip+import qualified Hydra.Substitution as Substitution+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+import qualified Data.Map as M++-- | DSL reference to hydra.json.encode.encodeFloat+encodeFloat :: Typed.TypedTerm Core.FloatValue -> Typed.TypedTerm (Either t0 Model.Value)+encodeFloat arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.encodeFloat")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.encode.encodeInteger+encodeInteger :: Typed.TypedTerm Core.IntegerValue -> Typed.TypedTerm (Either t0 Model.Value)+encodeInteger arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.encodeInteger")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.encode.encodeLiteral+encodeLiteral :: Typed.TypedTerm Core.Literal -> Typed.TypedTerm (Either t0 Model.Value)+encodeLiteral arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.encodeLiteral")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.encode.requiresJsonStringSentinel+requiresJsonStringSentinel :: Typed.TypedTerm String -> Typed.TypedTerm Bool+requiresJsonStringSentinel arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.requiresJsonStringSentinel")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.encode.toJson+toJson :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either String Model.Value)+toJson 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.json.encode.toJson")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.json.encode.toJsonUntyped+toJsonUntyped :: Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either String Model.Value)+toJsonUntyped arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.toJsonUntyped")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -5,7 +5,9 @@ module Hydra.Dsl.Json.Model where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Json.Model as DecodeJsonModel import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Encode.Json.Model as EncodeJsonModel import qualified Hydra.Json.Model as Model import qualified Hydra.Typed as Typed import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)@@ -64,3 +66,7 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "string"),         Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.json.model.Value+valueValue :: Typed.TypedName Model.Value+valueValue = Typed.TypedName (Core.Name "hydra.json.model.Value")

@@ -0,0 +1,143 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.json.parser++module Hydra.Dsl.Json.Parser 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.Json.Parser as Parser+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsers as Parsers+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.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.json.parser.digit+digit :: Typed.TypedTerm (Parsing.Parser Int)+digit = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.digit"))++-- | DSL reference to hydra.json.parser.digits+digits :: Typed.TypedTerm (Parsing.Parser String)+digits = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.digits"))++-- | DSL reference to hydra.json.parser.jsonArray+jsonArray :: Typed.TypedTerm (Parsing.Parser Model.Value)+jsonArray = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonArray"))++-- | DSL reference to hydra.json.parser.jsonBool+jsonBool :: Typed.TypedTerm (Parsing.Parser Model.Value)+jsonBool = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonBool"))++-- | DSL reference to hydra.json.parser.jsonEscapeChar+jsonEscapeChar :: Typed.TypedTerm (Parsing.Parser Int)+jsonEscapeChar = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonEscapeChar"))++-- | DSL reference to hydra.json.parser.jsonExponentPart+jsonExponentPart :: Typed.TypedTerm (Parsing.Parser (Maybe String))+jsonExponentPart = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonExponentPart"))++-- | DSL reference to hydra.json.parser.jsonFractionPart+jsonFractionPart :: Typed.TypedTerm (Parsing.Parser (Maybe String))+jsonFractionPart = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonFractionPart"))++-- | DSL reference to hydra.json.parser.jsonIntegerPart+jsonIntegerPart :: Typed.TypedTerm (Parsing.Parser String)+jsonIntegerPart = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonIntegerPart"))++-- | DSL reference to hydra.json.parser.jsonKeyValue+jsonKeyValue :: Typed.TypedTerm (Parsing.Parser (String, Model.Value))+jsonKeyValue = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonKeyValue"))++-- | DSL reference to hydra.json.parser.jsonNull+jsonNull :: Typed.TypedTerm (Parsing.Parser Model.Value)+jsonNull = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonNull"))++-- | DSL reference to hydra.json.parser.jsonNumber+jsonNumber :: Typed.TypedTerm (Parsing.Parser Model.Value)+jsonNumber = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonNumber"))++-- | DSL reference to hydra.json.parser.jsonObject+jsonObject :: Typed.TypedTerm (Parsing.Parser Model.Value)+jsonObject = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonObject"))++-- | DSL reference to hydra.json.parser.jsonString+jsonString :: Typed.TypedTerm (Parsing.Parser Model.Value)+jsonString = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonString"))++-- | DSL reference to hydra.json.parser.jsonStringChar+jsonStringChar :: Typed.TypedTerm (Parsing.Parser Int)+jsonStringChar = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonStringChar"))++-- | DSL reference to hydra.json.parser.jsonValue+jsonValue :: Typed.TypedTerm (Parsing.Parser Model.Value)+jsonValue = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonValue"))++-- | DSL reference to hydra.json.parser.parseJson+parseJson :: Typed.TypedTerm String -> Typed.TypedTerm (Parsing.ParseResult Model.Value)+parseJson arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.parser.parseJson")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.parser.token+token :: Typed.TypedTerm (Parsing.Parser t0) -> Typed.TypedTerm (Parsing.Parser t0)+token arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.parser.token")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.parser.whitespace+whitespace :: Typed.TypedTerm (Parsing.Parser ())+whitespace = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.whitespace"))

@@ -0,0 +1,105 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.json.writer++module Hydra.Dsl.Json.Writer 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.Serialization as DslSerialization+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.Json.Writer as Writer+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Serialization as Serialization+import qualified Hydra.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.json.writer.colonOp+colonOp :: Typed.TypedTerm Ast.Op+colonOp = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.writer.colonOp"))++-- | DSL reference to hydra.json.writer.hexByte+hexByte :: Typed.TypedTerm Int -> Typed.TypedTerm String+hexByte arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.hexByte")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.writer.jsonString+jsonString :: Typed.TypedTerm String -> Typed.TypedTerm String+jsonString arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.jsonString")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.writer.keyValueToExpr+keyValueToExpr :: Typed.TypedTerm (String, Model.Value) -> Typed.TypedTerm Ast.Expr+keyValueToExpr arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.keyValueToExpr")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.writer.printJson+printJson :: Typed.TypedTerm Model.Value -> Typed.TypedTerm String+printJson arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.printJson")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.writer.valueToExpr+valueToExpr :: Typed.TypedTerm Model.Value -> Typed.TypedTerm Ast.Expr+valueToExpr arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.valueToExpr")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -0,0 +1,89 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.json.yaml.decode++module Hydra.Dsl.Json.Yaml.Decode where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.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.Decode as JsonDecode+import qualified Hydra.Dsl.Json.Model as DslJsonModel+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.Dsl.Yaml.Model as DslYamlModel+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.Decode as Decode+import qualified Hydra.Json.Model as JsonModel+import qualified Hydra.Json.Yaml.Decode as YamlDecode+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.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 qualified Hydra.Yaml.Model as YamlModel+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M++-- | DSL reference to hydra.json.yaml.decode.fromYaml+fromYaml :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm YamlModel.Node -> Typed.TypedTerm (Either String Core.Term)+fromYaml 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.json.yaml.decode.fromYaml")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.json.yaml.decode.yamlToJson+yamlToJson :: Typed.TypedTerm YamlModel.Node -> Typed.TypedTerm (Either String JsonModel.Value)+yamlToJson arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.yaml.decode.yamlToJson")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -0,0 +1,89 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.json.yaml.encode++module Hydra.Dsl.Json.Yaml.Encode where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.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.Encode as JsonEncode+import qualified Hydra.Dsl.Json.Model as DslJsonModel+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.Dsl.Yaml.Model as DslYamlModel+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.Encode as Encode+import qualified Hydra.Json.Model as JsonModel+import qualified Hydra.Json.Yaml.Encode as YamlEncode+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.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 qualified Hydra.Yaml.Model as YamlModel+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M++-- | DSL reference to hydra.json.yaml.encode.jsonToYaml+jsonToYaml :: Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm YamlModel.Node+jsonToYaml arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.yaml.encode.jsonToYaml")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.json.yaml.encode.toYaml+toYaml :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either String YamlModel.Node)+toYaml 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.json.yaml.encode.toYaml")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))

@@ -0,0 +1,299 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.lexical++module Hydra.Dsl.Lexical 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.Scoping as DslScoping+import qualified Hydra.Dsl.Strip as DslStrip+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.Lexical as Lexical+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Strip as Strip+import qualified Hydra.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+import qualified Data.Map as M+import qualified Data.Set as S++-- | DSL reference to hydra.lexical.buildGraph+buildGraph :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (M.Map Core.Name (Maybe Core.Term)) -> Typed.TypedTerm (M.Map Core.Name Graph.Primitive) -> Typed.TypedTerm Graph.Graph+buildGraph 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.lexical.buildGraph")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.lexical.chooseUniqueName+chooseUniqueName :: Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name+chooseUniqueName arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.chooseUniqueName")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.dereferenceSchemaType+dereferenceSchemaType :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm (Maybe Core.TypeScheme)+dereferenceSchemaType arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.dereferenceSchemaType")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.dereferenceVariable+dereferenceVariable :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.Binding)+dereferenceVariable arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.dereferenceVariable")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.elementsToGraph+elementsToGraph :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Graph.Graph+elementsToGraph 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.lexical.elementsToGraph")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.lexical.emptyGraph+emptyGraph :: Typed.TypedTerm Graph.Graph+emptyGraph = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.lexical.emptyGraph"))++-- | DSL reference to hydra.lexical.emptyInferenceContext+emptyInferenceContext :: Typed.TypedTerm Typing.InferenceContext+emptyInferenceContext = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.lexical.emptyInferenceContext"))++-- | DSL reference to hydra.lexical.fieldsOf+fieldsOf :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Core.FieldType]+fieldsOf arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.fieldsOf")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.lexical.getField+getField :: Typed.TypedTerm (M.Map Core.Name t0) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (t0 -> Either Errors.Error t1) -> Typed.TypedTerm (Either Errors.Error t1)+getField 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.lexical.getField")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.lexical.graphToBindings+graphToBindings :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Binding]+graphToBindings arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.graphToBindings")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.lexical.graphWithPrimitives+graphWithPrimitives :: Typed.TypedTerm [Graph.Primitive] -> Typed.TypedTerm [Graph.Primitive] -> Typed.TypedTerm Graph.Graph+graphWithPrimitives arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.graphWithPrimitives")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.lookupBinding+lookupBinding :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Binding)+lookupBinding arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.lookupBinding")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.lookupPrimitive+lookupPrimitive :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Graph.Primitive)+lookupPrimitive arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.lookupPrimitive")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.lookupTerm+lookupTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term)+lookupTerm arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.lookupTerm")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.matchEnum+matchEnum :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm [(Core.Name, t0)] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error t0)+matchEnum 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.lexical.matchEnum")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.lexical.matchRecord+matchRecord :: Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map Core.Name Core.Term -> Either Errors.Error t1) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error t1)+matchRecord 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.lexical.matchRecord")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.lexical.matchUnion+matchUnion :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm [(Core.Name, (Core.Term -> Either Errors.Error t0))] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error t0)+matchUnion 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.lexical.matchUnion")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.lexical.matchUnitField+matchUnitField :: Typed.TypedTerm t0 -> Typed.TypedTerm t1 -> Typed.TypedTerm (t0, (t2 -> Either t3 t1))+matchUnitField arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.matchUnitField")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.requireBinding+requireBinding :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.Binding)+requireBinding arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.requireBinding")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.requirePrimitive+requirePrimitive :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Graph.Primitive)+requirePrimitive arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.requirePrimitive")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.requirePrimitiveType+requirePrimitiveType :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.TypeScheme)+requirePrimitiveType arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.requirePrimitiveType")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.requireTerm+requireTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.Term)+requireTerm arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.requireTerm")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.resolveTerm+resolveTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term)+resolveTerm arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.resolveTerm")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.stripAndDereferenceTerm+stripAndDereferenceTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error Core.Term)+stripAndDereferenceTerm arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTerm")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.lexical.stripAndDereferenceTermEither+stripAndDereferenceTermEither :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error Core.Term)+stripAndDereferenceTermEither arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))

@@ -0,0 +1,26 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.lib.defaults++module Hydra.Dsl.Lib.Defaults where++import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Lib.Eithers as Eithers+import qualified Hydra.Dsl.Lib.Equality as Equality+import qualified Hydra.Dsl.Lib.Lists as Lists+import qualified Hydra.Dsl.Lib.Logic as Logic+import qualified Hydra.Dsl.Lib.Maps as Maps+import qualified Hydra.Dsl.Lib.Math as Math+import qualified Hydra.Dsl.Lib.Optionals as Optionals+import qualified Hydra.Dsl.Lib.Pairs as Pairs+import qualified Hydra.Dsl.Lib.Sets as Sets+import qualified Hydra.Lib.Defaults as Defaults+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M++-- | DSL reference to hydra.lib.defaults.defaultImplementations+defaultImplementations :: Typed.TypedTerm (M.Map Core.Name Core.Term)+defaultImplementations = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.lib.defaults.defaultImplementations"))

@@ -0,0 +1,229 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.names++module Hydra.Dsl.Names where++import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Docs as Docs+import qualified Hydra.Dsl.Annotations as DslAnnotations+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Constants as DslConstants+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.Formatting as DslFormatting+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.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.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+import qualified Data.Map as M+import qualified Data.Set as S++-- | DSL reference to hydra.names.chooseUniqueLabel+chooseUniqueLabel :: Typed.TypedTerm (S.Set String) -> Typed.TypedTerm String -> Typed.TypedTerm String+chooseUniqueLabel arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.chooseUniqueLabel")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.names.compactName+compactName :: Typed.TypedTerm (M.Map Packaging.ModuleName String) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm String+compactName arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.compactName")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.names.derivedBindingName+derivedBindingName :: Typed.TypedTerm [String] -> Typed.TypedTerm Bool -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name+derivedBindingName 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.names.derivedBindingName")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.names.derivedDefinitionName+derivedDefinitionName :: Typed.TypedTerm [String] -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Core.Name -> Typed.TypedTerm String -> Typed.TypedTerm Core.Name+derivedDefinitionName arg0 arg1 arg2 arg3 arg4 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.derivedDefinitionName")),+              Core.applicationArgument = (Typed.unTypedTerm arg0)})),+            Core.applicationArgument = (Typed.unTypedTerm arg1)})),+          Core.applicationArgument = (Typed.unTypedTerm arg2)})),+        Core.applicationArgument = (Typed.unTypedTerm arg3)})),+      Core.applicationArgument = (Typed.unTypedTerm arg4)}))++-- | DSL reference to hydra.names.derivedModuleName+derivedModuleName :: Typed.TypedTerm [String] -> Typed.TypedTerm Bool -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.ModuleName+derivedModuleName 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.names.derivedModuleName")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.names.freshName+freshName :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (Core.Name, Typing.InferenceContext)+freshName arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.freshName")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.names.freshNames+freshNames :: Typed.TypedTerm Int -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm ([Core.Name], Typing.InferenceContext)+freshNames arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.freshNames")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.names.localNameOf+localNameOf :: Typed.TypedTerm Core.Name -> Typed.TypedTerm String+localNameOf arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.localNameOf")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.names.moduleNameOf+moduleNameOf :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Packaging.ModuleName)+moduleNameOf arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.moduleNameOf")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.names.moduleNameToFilePath+moduleNameToFilePath :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm File.FileExtension -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm String+moduleNameToFilePath 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.names.moduleNameToFilePath")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.names.nameToFilePath+nameToFilePath :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm File.FileExtension -> Typed.TypedTerm Core.Name -> Typed.TypedTerm String+nameToFilePath 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.names.nameToFilePath")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.names.normalTypeVariable+normalTypeVariable :: Typed.TypedTerm Int -> Typed.TypedTerm Core.Name+normalTypeVariable arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.normalTypeVariable")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.names.pushSubtermStep+pushSubtermStep :: Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Typing.InferenceContext+pushSubtermStep arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.pushSubtermStep")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.names.qname+qname :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm String -> Typed.TypedTerm Core.Name+qname arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.qname")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.names.qualifyName+qualifyName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Util.QualifiedName+qualifyName arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.qualifyName")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.names.restoreTrace+restoreTrace :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Typing.InferenceContext+restoreTrace arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.restoreTrace")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.names.unqualifyName+unqualifyName :: Typed.TypedTerm Util.QualifiedName -> Typed.TypedTerm Core.Name+unqualifyName arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.unqualifyName")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -5,14 +5,20 @@ module Hydra.Dsl.Packaging where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Packaging as DecodePackaging import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Encode.Packaging as EncodePackaging import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL name token for hydra.packaging.Definition+definitionDefinition :: Typed.TypedName Packaging.Definition+definitionDefinition = Typed.TypedName (Core.Name "hydra.packaging.Definition")+ -- | DSL injection for the primitive variant of hydra.packaging.Definition definitionPrimitive :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Packaging.Definition definitionPrimitive x =@@ -22,6 +28,10 @@         Core.fieldName = (Core.Name "primitive"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.packaging.DefinitionReference+definitionReferenceDefinitionReference :: Typed.TypedName Packaging.DefinitionReference+definitionReferenceDefinitionReference = Typed.TypedName (Core.Name "hydra.packaging.DefinitionReference")+ -- | DSL injection for the primitive variant of hydra.packaging.DefinitionReference definitionReferencePrimitive :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.DefinitionReference definitionReferencePrimitive x =@@ -76,6 +86,10 @@         Core.fieldName = (Core.Name "api"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.packaging.DependencyScope+dependencyScopeDependencyScope :: Typed.TypedName Packaging.DependencyScope+dependencyScopeDependencyScope = Typed.TypedName (Core.Name "hydra.packaging.DependencyScope")+ -- | DSL injection for the runtime variant of hydra.packaging.DependencyScope dependencyScopeRuntime :: Typed.TypedTerm Packaging.DependencyScope dependencyScopeRuntime =@@ -140,6 +154,10 @@         Core.projectionFieldName = (Core.Name "description")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.EntityMetadata+entityMetadataEntityMetadata :: Typed.TypedName Packaging.EntityMetadata+entityMetadataEntityMetadata = Typed.TypedName (Core.Name "hydra.packaging.EntityMetadata")+ -- | DSL accessor for the lifecycle field of hydra.packaging.EntityMetadata entityMetadataLifecycle :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm (Maybe Packaging.LifecycleInfo) entityMetadataLifecycle x =@@ -291,6 +309,10 @@         Core.fieldName = (Core.Name "definition"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.packaging.EntityReference+entityReferenceEntityReference :: Typed.TypedName Packaging.EntityReference+entityReferenceEntityReference = Typed.TypedName (Core.Name "hydra.packaging.EntityReference")+ -- | DSL injection for the module variant of hydra.packaging.EntityReference entityReferenceModule :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.EntityReference entityReferenceModule x =@@ -358,6 +380,10 @@         Core.projectionFieldName = (Core.Name "deprecatedSince")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.LifecycleInfo+lifecycleInfoLifecycleInfo :: Typed.TypedName Packaging.LifecycleInfo+lifecycleInfoLifecycleInfo = Typed.TypedName (Core.Name "hydra.packaging.LifecycleInfo")+ -- | DSL updater for the availableSince field of hydra.packaging.LifecycleInfo lifecycleInfoWithAvailableSince :: Typed.TypedTerm Packaging.LifecycleInfo -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Packaging.LifecycleInfo lifecycleInfoWithAvailableSince original newVal =@@ -451,6 +477,10 @@         Core.projectionFieldName = (Core.Name "module")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.ModuleDependency+moduleDependencyModuleDependency :: Typed.TypedName Packaging.ModuleDependency+moduleDependencyModuleDependency = Typed.TypedName (Core.Name "hydra.packaging.ModuleDependency")+ -- | DSL accessor for the package field of hydra.packaging.ModuleDependency moduleDependencyPackage :: Typed.TypedTerm Packaging.ModuleDependency -> Typed.TypedTerm (Maybe Packaging.PackageName) moduleDependencyPackage x =@@ -503,6 +533,10 @@         Core.projectionFieldName = (Core.Name "metadata")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.Module+moduleModule :: Typed.TypedName Packaging.Module+moduleModule = Typed.TypedName (Core.Name "hydra.packaging.Module")+ -- | DSL accessor for the name field of hydra.packaging.Module moduleName :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Packaging.ModuleName moduleName x =@@ -519,6 +553,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.packaging.ModuleName"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.ModuleName+moduleNameModuleName :: Typed.TypedName Packaging.ModuleName+moduleNameModuleName = Typed.TypedName (Core.Name "hydra.packaging.ModuleName")+ -- | DSL updater for the definitions field of hydra.packaging.Module moduleWithDefinitions :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm Packaging.Module moduleWithDefinitions original newVal =@@ -696,6 +734,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.PackageDependency+packageDependencyPackageDependency :: Typed.TypedName Packaging.PackageDependency+packageDependencyPackageDependency = Typed.TypedName (Core.Name "hydra.packaging.PackageDependency")+ -- | DSL accessor for the scope field of hydra.packaging.PackageDependency packageDependencyScope :: Typed.TypedTerm Packaging.PackageDependency -> Typed.TypedTerm (Maybe Packaging.DependencyScope) packageDependencyScope x =@@ -820,6 +862,14 @@       Core.wrappedTermTypeName = (Core.Name "hydra.packaging.PackageName"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.PackageName+packageNamePackageName :: Typed.TypedName Packaging.PackageName+packageNamePackageName = Typed.TypedName (Core.Name "hydra.packaging.PackageName")++-- | DSL name token for hydra.packaging.Package+packagePackage :: Typed.TypedName Packaging.Package+packagePackage = Typed.TypedName (Core.Name "hydra.packaging.Package")+ -- | DSL updater for the dependencies field of hydra.packaging.Package packageWithDependencies :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm [Packaging.PackageDependency] -> Typed.TypedTerm Packaging.Package packageWithDependencies original newVal =@@ -1014,6 +1064,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.PrimitiveDefinition+primitiveDefinitionPrimitiveDefinition :: Typed.TypedName Packaging.PrimitiveDefinition+primitiveDefinitionPrimitiveDefinition = Typed.TypedName (Core.Name "hydra.packaging.PrimitiveDefinition")+ -- | DSL accessor for the signature field of hydra.packaging.PrimitiveDefinition primitiveDefinitionSignature :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Typing.TermSignature primitiveDefinitionSignature x =@@ -1348,6 +1402,10 @@         Core.projectionFieldName = (Core.Name "signature")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.TermDefinition+termDefinitionTermDefinition :: Typed.TypedName Packaging.TermDefinition+termDefinitionTermDefinition = Typed.TypedName (Core.Name "hydra.packaging.TermDefinition")+ -- | DSL updater for the body field of hydra.packaging.TermDefinition termDefinitionWithBody :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Packaging.TermDefinition termDefinitionWithBody original newVal =@@ -1515,6 +1573,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.TypeDefinition+typeDefinitionTypeDefinition :: Typed.TypedName Packaging.TypeDefinition+typeDefinitionTypeDefinition = Typed.TypedName (Core.Name "hydra.packaging.TypeDefinition")+ -- | DSL updater for the body field of hydra.packaging.TypeDefinition typeDefinitionWithBody :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Packaging.TypeDefinition typeDefinitionWithBody original newVal =@@ -1646,6 +1708,10 @@         Core.projectionFieldName = (Core.Name "upperExclusive")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.VersionRange+versionRangeVersionRange :: Typed.TypedName Packaging.VersionRange+versionRangeVersionRange = Typed.TypedName (Core.Name "hydra.packaging.VersionRange")+ -- | DSL updater for the lowerInclusive field of hydra.packaging.VersionRange versionRangeWithLowerInclusive :: Typed.TypedTerm Packaging.VersionRange -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Packaging.VersionRange versionRangeWithLowerInclusive original newVal =@@ -1715,3 +1781,11 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "range"),         Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.packaging.VersionSpecifier+versionSpecifierVersionSpecifier :: Typed.TypedName Packaging.VersionSpecifier+versionSpecifierVersionSpecifier = Typed.TypedName (Core.Name "hydra.packaging.VersionSpecifier")++-- | DSL name token for hydra.packaging.Version+versionVersion :: Typed.TypedName Packaging.Version+versionVersion = Typed.TypedName (Core.Name "hydra.packaging.Version")

@@ -5,12 +5,58 @@ module Hydra.Dsl.Parsing where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Parsing as DecodeParsing import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Encode.Parsing as EncodeParsing+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph import qualified Hydra.Parsing as Parsing import qualified Hydra.Typed as Typed import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL composition builder for the decoder of hydra.parsing.ParseResult+decodeParseResult :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseResult a))+decodeParseResult a =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parseResult")),+      Core.applicationArgument = (Typed.unTypedTerm a)}))++-- | DSL composition builder for the decoder of hydra.parsing.ParseSuccess+decodeParseSuccess :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseSuccess a))+decodeParseSuccess a =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parseSuccess")),+      Core.applicationArgument = (Typed.unTypedTerm a)}))++-- | DSL composition builder for the decoder of hydra.parsing.Parser+decodeParser :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.Parser a))+decodeParser a =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parser")),+      Core.applicationArgument = (Typed.unTypedTerm a)}))++-- | DSL composition builder for the encoder of hydra.parsing.ParseResult+encodeParseResult :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Parsing.ParseResult a -> Core.Term)+encodeParseResult a =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parseResult")),+      Core.applicationArgument = (Typed.unTypedTerm a)}))++-- | DSL composition builder for the encoder of hydra.parsing.ParseSuccess+encodeParseSuccess :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Parsing.ParseSuccess a -> Core.Term)+encodeParseSuccess a =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parseSuccess")),+      Core.applicationArgument = (Typed.unTypedTerm a)}))++-- | DSL composition builder for the encoder of hydra.parsing.Parser+encodeParser :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Parsing.Parser a -> Core.Term)+encodeParser a =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parser")),+      Core.applicationArgument = (Typed.unTypedTerm a)}))+ -- | DSL constructor for hydra.parsing.ParseError parseError :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Parsing.ParseError parseError message remainder =@@ -33,6 +79,10 @@         Core.projectionFieldName = (Core.Name "message")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.parsing.ParseError+parseErrorParseError :: Typed.TypedName Parsing.ParseError+parseErrorParseError = Typed.TypedName (Core.Name "hydra.parsing.ParseError")+ -- | DSL accessor for the remainder field of hydra.parsing.ParseError parseErrorRemainder :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm String parseErrorRemainder x =@@ -85,6 +135,10 @@         Core.fieldName = (Core.Name "failure"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.parsing.ParseResult+parseResultParseResult :: Typed.TypedName (Parsing.ParseResult a)+parseResultParseResult = Typed.TypedName (Core.Name "hydra.parsing.ParseResult")+ -- | DSL injection for the success variant of hydra.parsing.ParseResult parseResultSuccess :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm (Parsing.ParseResult a) parseResultSuccess x =@@ -107,6 +161,10 @@           Core.fieldName = (Core.Name "remainder"),           Core.fieldTerm = (Typed.unTypedTerm remainder)}]})) +-- | DSL name token for hydra.parsing.ParseSuccess+parseSuccessParseSuccess :: Typed.TypedName (Parsing.ParseSuccess a)+parseSuccessParseSuccess = Typed.TypedName (Core.Name "hydra.parsing.ParseSuccess")+ -- | DSL accessor for the remainder field of hydra.parsing.ParseSuccess parseSuccessRemainder :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm String parseSuccessRemainder x =@@ -165,6 +223,10 @@     Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {       Core.wrappedTermTypeName = (Core.Name "hydra.parsing.Parser"),       Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.parsing.Parser+parserParser :: Typed.TypedName (Parsing.Parser a)+parserParser = Typed.TypedName (Core.Name "hydra.parsing.Parser")  -- | DSL accessor for the body of hydra.parsing.Parser unParser :: Typed.TypedTerm (Parsing.Parser a) -> Typed.TypedTerm (String -> Parsing.ParseResult a)

@@ -5,7 +5,9 @@ module Hydra.Dsl.Paths where  import qualified Hydra.Core as Core+import qualified Hydra.Decode.Paths as DecodePaths import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Encode.Paths as EncodePaths import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)@@ -45,6 +47,10 @@         Core.projectionFieldName = (Core.Name "source")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtermEdge+subtermEdgeSubtermEdge :: Typed.TypedName Paths.SubtermEdge+subtermEdgeSubtermEdge = Typed.TypedName (Core.Name "hydra.paths.SubtermEdge")+ -- | DSL accessor for the target field of hydra.paths.SubtermEdge subtermEdgeTarget :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermNode subtermEdgeTarget x =@@ -157,6 +163,10 @@         Core.projectionFieldName = (Core.Name "nodes")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtermGraph+subtermGraphSubtermGraph :: Typed.TypedName Paths.SubtermGraph+subtermGraphSubtermGraph = Typed.TypedName (Core.Name "hydra.paths.SubtermGraph")+ -- | DSL updater for the edges field of hydra.paths.SubtermGraph subtermGraphWithEdges :: Typed.TypedTerm Paths.SubtermGraph -> Typed.TypedTerm [Paths.SubtermEdge] -> Typed.TypedTerm Paths.SubtermGraph subtermGraphWithEdges original newVal =@@ -234,6 +244,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtermNode+subtermNodeSubtermNode :: Typed.TypedName Paths.SubtermNode+subtermNodeSubtermNode = Typed.TypedName (Core.Name "hydra.paths.SubtermNode")+ -- | DSL updater for the id field of hydra.paths.SubtermNode subtermNodeWithId :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtermNode subtermNodeWithId original newVal =@@ -313,6 +327,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtermPath+subtermPathSubtermPath :: Typed.TypedName Paths.SubtermPath+subtermPathSubtermPath = Typed.TypedName (Core.Name "hydra.paths.SubtermPath")+ -- | DSL injection for the annotatedBody variant of hydra.paths.SubtermStep subtermStepAnnotatedBody :: Typed.TypedTerm Paths.SubtermStep subtermStepAnnotatedBody =@@ -439,6 +457,10 @@         Core.fieldName = (Core.Name "setElement"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.paths.SubtermStep+subtermStepSubtermStep :: Typed.TypedName Paths.SubtermStep+subtermStepSubtermStep = Typed.TypedName (Core.Name "hydra.paths.SubtermStep")+ -- | DSL injection for the sumTerm variant of hydra.paths.SubtermStep subtermStepSumTerm :: Typed.TypedTerm Paths.SubtermStep subtermStepSumTerm =@@ -527,6 +549,10 @@         Core.projectionFieldName = (Core.Name "source")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtypeEdge+subtypeEdgeSubtypeEdge :: Typed.TypedName Paths.SubtypeEdge+subtypeEdgeSubtypeEdge = Typed.TypedName (Core.Name "hydra.paths.SubtypeEdge")+ -- | DSL accessor for the target field of hydra.paths.SubtypeEdge subtypeEdgeTarget :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypeNode subtypeEdgeTarget x =@@ -639,6 +665,10 @@         Core.projectionFieldName = (Core.Name "nodes")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtypeGraph+subtypeGraphSubtypeGraph :: Typed.TypedName Paths.SubtypeGraph+subtypeGraphSubtypeGraph = Typed.TypedName (Core.Name "hydra.paths.SubtypeGraph")+ -- | DSL updater for the edges field of hydra.paths.SubtypeGraph subtypeGraphWithEdges :: Typed.TypedTerm Paths.SubtypeGraph -> Typed.TypedTerm [Paths.SubtypeEdge] -> Typed.TypedTerm Paths.SubtypeGraph subtypeGraphWithEdges original newVal =@@ -716,6 +746,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtypeNode+subtypeNodeSubtypeNode :: Typed.TypedName Paths.SubtypeNode+subtypeNodeSubtypeNode = Typed.TypedName (Core.Name "hydra.paths.SubtypeNode")+ -- | DSL updater for the id field of hydra.paths.SubtypeNode subtypeNodeWithId :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtypeNode subtypeNodeWithId original newVal =@@ -795,6 +829,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtypePath+subtypePathSubtypePath :: Typed.TypedName Paths.SubtypePath+subtypePathSubtypePath = Typed.TypedName (Core.Name "hydra.paths.SubtypePath")+ -- | DSL injection for the annotatedBody variant of hydra.paths.SubtypeStep subtypeStepAnnotatedBody :: Typed.TypedTerm Paths.SubtypeStep subtypeStepAnnotatedBody =@@ -938,6 +976,10 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "setElement"),         Core.fieldTerm = Core.TermUnit}}))++-- | DSL name token for hydra.paths.SubtypeStep+subtypeStepSubtypeStep :: Typed.TypedName Paths.SubtypeStep+subtypeStepSubtypeStep = Typed.TypedName (Core.Name "hydra.paths.SubtypeStep")  -- | DSL injection for the unionField variant of hydra.paths.SubtypeStep subtypeStepUnionField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeStep

@@ -0,0 +1,213 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.predicates++module Hydra.Dsl.Predicates where++import qualified Hydra.Arity as Arity+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Dependencies as Dependencies+import qualified Hydra.Docs as Docs+import qualified Hydra.Dsl.Arity as DslArity+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.Dependencies as DslDependencies+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.Lexical as DslLexical+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.Rewriting as DslRewriting+import qualified Hydra.Dsl.Scoping as DslScoping+import qualified Hydra.Dsl.Strip as DslStrip+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.Lexical as Lexical+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Predicates as Predicates+import qualified Hydra.Query as Query+import qualified Hydra.Reflect as Reflect+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Strip as Strip+import qualified Hydra.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+import qualified Data.Map as M++-- | DSL reference to hydra.predicates.isComplexBinding+isComplexBinding :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm Bool+isComplexBinding arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isComplexBinding")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.predicates.isComplexTerm+isComplexTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isComplexTerm arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isComplexTerm")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.predicates.isComplexVariable+isComplexVariable :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Bool+isComplexVariable arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isComplexVariable")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.predicates.isEncodedTerm+isEncodedTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isEncodedTerm arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isEncodedTerm")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isEncodedType+isEncodedType :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isEncodedType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isEncodedType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isEnumRowType+isEnumRowType :: Typed.TypedTerm [Core.FieldType] -> Typed.TypedTerm Bool+isEnumRowType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isEnumRowType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isEnumType+isEnumType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool+isEnumType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isEnumType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isNominalType+isNominalType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool+isNominalType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isNominalType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isSerializable+isSerializable :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm (Either Errors.Error Bool)+isSerializable 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.predicates.isSerializable")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.predicates.isSerializableByName+isSerializableByName :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Bool)+isSerializableByName 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.predicates.isSerializableByName")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.predicates.isSerializableType+isSerializableType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool+isSerializableType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isSerializableType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isTrivialTerm+isTrivialTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isTrivialTerm arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isTrivialTerm")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isType+isType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool+isType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isUnitTerm+isUnitTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool+isUnitTerm arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isUnitTerm")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.isUnitType+isUnitType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool+isUnitType arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isUnitType")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.predicates.typeDependencies+typeDependencies :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Bool -> Typed.TypedTerm (Core.Type -> Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (M.Map Core.Name Core.Type))+typeDependencies arg0 arg1 arg2 arg3 arg4 =+    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.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.typeDependencies")),+              Core.applicationArgument = (Typed.unTypedTerm arg0)})),+            Core.applicationArgument = (Typed.unTypedTerm arg1)})),+          Core.applicationArgument = (Typed.unTypedTerm arg2)})),+        Core.applicationArgument = (Typed.unTypedTerm arg3)})),+      Core.applicationArgument = (Typed.unTypedTerm arg4)}))