hydra-kernel 0.17.6 → 0.17.7

raw patch · 68 files changed

+4985/−2371 lines, 68 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +82/−0
• hydra-kernel.cabal +3/−2
• src/main/haskell/Hydra/Codegen.hs +2/−1
• src/main/haskell/Hydra/Decode/Error/Packaging.hs +29/−0
• src/main/haskell/Hydra/Decode/Packaging.hs +41/−2
• src/main/haskell/Hydra/Decode/Paths.hs +244/−151
• src/main/haskell/Hydra/Decode/Util.hs +4/−1
• src/main/haskell/Hydra/Decoding.hs +8/−3
• src/main/haskell/Hydra/Dsl/Error/Packaging.hs +207/−0
• src/main/haskell/Hydra/Dsl/Names.hs +16/−0
• src/main/haskell/Hydra/Dsl/Packaging.hs +222/−3
• src/main/haskell/Hydra/Dsl/Paths.hs +1744/−1263
• src/main/haskell/Hydra/Dsl/Testing.hs +82/−4
• src/main/haskell/Hydra/Dsl/Util.hs +9/−0
• src/main/haskell/Hydra/Dsls.hs +2/−1
• src/main/haskell/Hydra/Encode/Error/Packaging.hs +39/−0
• src/main/haskell/Hydra/Encode/Packaging.hs +35/−1
• src/main/haskell/Hydra/Encode/Paths.hs +290/−176
• src/main/haskell/Hydra/Encode/Util.hs +5/−0
• src/main/haskell/Hydra/Encoding.hs +2/−1
• src/main/haskell/Hydra/Error/Packaging.hs +42/−0
• src/main/haskell/Hydra/Formatting.hs +3/−0
• src/main/haskell/Hydra/Json/Bootstrap.hs +69/−2
• src/main/haskell/Hydra/Json/Decode.hs +12/−10
• src/main/haskell/Hydra/Json/Parser.hs +1/−1
• src/main/haskell/Hydra/Json/Writer.hs +5/−1
• src/main/haskell/Hydra/Lib/Chars.hs +16/−8
• src/main/haskell/Hydra/Lib/Effects.hs +18/−9
• src/main/haskell/Hydra/Lib/Eithers.hs +34/−17
• src/main/haskell/Hydra/Lib/Equality.hs +4/−2
• src/main/haskell/Hydra/Lib/Files.hs +26/−13
• src/main/haskell/Hydra/Lib/Functions.hs +10/−5
• src/main/haskell/Hydra/Lib/Hashing.hs +4/−2
• src/main/haskell/Hydra/Lib/Lists.hs +84/−42
• src/main/haskell/Hydra/Lib/Literals.hs +110/−55
• src/main/haskell/Hydra/Lib/Logic.hs +8/−4
• src/main/haskell/Hydra/Lib/Maps.hs +46/−23
• src/main/haskell/Hydra/Lib/Math.hs +86/−43
• src/main/haskell/Hydra/Lib/Optionals.hs +30/−15
• src/main/haskell/Hydra/Lib/Ordering.hs +14/−7
• src/main/haskell/Hydra/Lib/Pairs.hs +8/−4
• src/main/haskell/Hydra/Lib/Regex.hs +12/−6
• src/main/haskell/Hydra/Lib/Sets.hs +30/−15
• src/main/haskell/Hydra/Lib/Strings.hs +22/−11
• src/main/haskell/Hydra/Lib/System.hs +18/−9
• src/main/haskell/Hydra/Lib/Text.hs +4/−2
• src/main/haskell/Hydra/Names.hs +16/−0
• src/main/haskell/Hydra/Overlay/Haskell/Bootstrap.hs +1/−1
• src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Phantoms.hs +2/−2
• src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Testing.hs +49/−5
• src/main/haskell/Hydra/Overlay/Haskell/Lib/Literals.hs +41/−6
• src/main/haskell/Hydra/Overlay/Haskell/Libraries.hs +200/−11
• src/main/haskell/Hydra/Packaging.hs +39/−2
• src/main/haskell/Hydra/Paths.hs +311/−191
• src/main/haskell/Hydra/Print/Error/Packaging.hs +22/−0
• src/main/haskell/Hydra/Print/Paths.hs +2/−3
• src/main/haskell/Hydra/Print/Util.hs +1/−0
• src/main/haskell/Hydra/Rewriting.hs +10/−8
• src/main/haskell/Hydra/Shredding.hs +0/−216
• src/main/haskell/Hydra/Subterms.hs +354/−0
• src/main/haskell/Hydra/Templates.hs +1/−1
• src/main/haskell/Hydra/Test/Transform.hs +2/−1
• src/main/haskell/Hydra/Test/Utils.hs +3/−1
• src/main/haskell/Hydra/Testing.hs +5/−1
• src/main/haskell/Hydra/Util.hs +4/−1
• src/main/haskell/Hydra/Validate/Core.hs +15/−3
• src/main/haskell/Hydra/Validate/Packaging.hs +51/−3
• src/main/haskell/Hydra/Validate/Paths.hs +74/−0

@@ -15,6 +15,88 @@  --- +## [0.17.7] - 2026-09-14++Correctness-hardening point release on the 0.17.x line, consolidating the 0.17.6 breaking batch. It+closes a family of silent cross-host correctness bugs in the equality, ordering, integer-narrowing+and string primitives, and adds the systematic test coverage that exposed them. No kernel-surface+breaking changes.++### Highlights++- **Silent-wrong primitives corrected across hosts**+  ([#745](https://github.com/CategoricalData/hydra/issues/745),+  [#742](https://github.com/CategoricalData/hydra/issues/742)): new shared cross-host fixtures+  uncovered ~a dozen primitives (`equal`/`compare` on collections, float equality, `bigintToIntN`+  narrowing, `parseUint*` bounds, astral-plane string ops) that returned wrong results on one or more+  non-Haskell hosts while appearing to pass. All are now correct and verified per-host against the+  Haskell reference oracle.+- **Systematic test-coverage hardening**+  ([#749](https://github.com/CategoricalData/hydra/issues/749)): new kernel coverage for previously+  untested primitive behavior (equality/ordering collection depth, `notEqual`, `functions.const`/`flip`),+  which drove wiring those primitives into every host's default-implementation fallback.+- **Scale-preserving decimals across every lossy-double host**+  ([#727](https://github.com/CategoricalData/hydra/issues/727),+  [#719](https://github.com/CategoricalData/hydra/issues/719)): `Literal.decimal` gains a real+  scale-preserving representation (coefficient + scale) in the Scheme, Emacs Lisp, Common Lisp and+  TypeScript runtimes and coders, and the generated `Literal.Decimal` `equals`/`compareTo` on Java,+  Python and Scala stop ignoring scale. The `scaleDistinctTestNames` skip list — which had been+  masking the gap on five hosts — is deleted, so decimal scale is now verified everywhere rather+  than excused.++### Bug fixes++- **[#745](https://github.com/CategoricalData/hydra/issues/745)** silent-wrong equality/ordering,+  `bigintToIntN` narrowing, `parseUint32/64` bounds, and astral-plane `charAt`/`splitOn`/`compare`+  across the eight non-Haskell hosts.+- **[#742](https://github.com/CategoricalData/hydra/issues/742)** structural `equal`/`compare` on+  maps, sets and nested decimals no longer falls back to scale-blind or print-based comparison+  (including a hand-inlined Scala primitive that shadowed the overlay fix).+- **[#743](https://github.com/CategoricalData/hydra/issues/743)** kernel JSON decoder now rejects an+  `Either` object carrying both `left` and `right` keys instead of silently resolving one arm.+- **[#740](https://github.com/CategoricalData/hydra/issues/740)** the recursive parametric union decoder+  now emits an explicit type application instead of an untyped lambda, so recursive parametric-union+  types generate and compile on the Java host; also fixes `update-json-kernel` reconcile to build a+  complete inference universe so drifted kernel modules re-infer.+- **[#720](https://github.com/CategoricalData/hydra/issues/720)** Python's+  `hydra.lib.equality`/`ordering` did not satisfy IEEE `totalOrder` for floats, mis-ordering `NaN`+  and signed zero.+- **[#722](https://github.com/CategoricalData/hydra/issues/722)** two `kernelDefaultCoreProfile`+  correctness defects: rule ids that referred to rules no longer present, and a stubbed+  `isValidName` that accepted every name.++### Improvements++- **[#749](https://github.com/CategoricalData/hydra/issues/749)** `notEqual`/`const`/`flip` wired+  into each host's `#609` default-implementation fallback; orphaned Avro coder test suite recovered.+- **[#730](https://github.com/CategoricalData/hydra/issues/730)** a shared `~/.stack` build slot+  (`bin/with-stack-slot.sh`) replaces the pgrep slot mechanic, serializing concurrent GHC builds+  across the fleet behind a real mutex. The wrapper is now portable to macOS: `flock(1)` is+  util-linux and absent there, so it is emulated via Perl's `flock()` where missing, and the+  GNU-only `date -Is`/`date -d` calls are replaced with portable equivalents. Its bypass path also+  no longer re-execs forever. Without these, every entry point that routes through the slot —+  `bin/sync.sh`, `bin/test.sh`, `bin/run-bootstrapping-demo.sh` and `bin/prepare-release.sh` —+  failed immediately on macOS.+- **[#600](https://github.com/CategoricalData/hydra/issues/600)** the five published TypeScript+  packages are subpath-import-only (uniform export surface).+- **[#716](https://github.com/CategoricalData/hydra/issues/716)** `hydra.paths` reshaped onto the+  term-graph model (`TermGraph`/`TypeGraph`), aligning path steps with the term and type grammars+  and adding the link view of a graph; `mapKey`/`mapValue` collapse into a single `mapEntry` step.+- **[#701](https://github.com/CategoricalData/hydra/issues/701)** module cache freshness is now a+  Merkle hash over each module's dependency closure, so a change deep in the closure correctly+  invalidates dependents.+- **[#559](https://github.com/CategoricalData/hydra/issues/559)** host-agnostic build: the+  remaining hand-coded host build logic is promoted into `hydra.build.*`, with Java as the+  definitive second host.+- **[#721](https://github.com/CategoricalData/hydra/issues/721)** `checkNestedModuleNames` packaging+  check enforces the module-namespace no-prefix rule.++### Documentation++- **[#508](https://github.com/CategoricalData/hydra/issues/508)** de-Claude-speak documentation pass:+  style-guide section added, stale paths and dead links repaired, agent-operations wiki pages moved+  into `claude/`, and a `getting-started.md` guardrail against re-adding a TypeScript root export.+ ## [0.17.6] - 2026-08-30  Point release on the 0.17.x line, and the last backward-incompatible batch before the 1.0 surface

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-kernel-version:        0.17.6+version:        0.17.7 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@@ -309,10 +309,10 @@       Hydra.Scoping       Hydra.Serialization       Hydra.Settings-      Hydra.Shredding       Hydra.Sorting       Hydra.Strip       Hydra.Substitution+      Hydra.Subterms       Hydra.System       Hydra.Tabular       Hydra.Templates@@ -327,6 +327,7 @@       Hydra.Util       Hydra.Validate.Core       Hydra.Validate.Packaging+      Hydra.Validate.Paths       Hydra.Validation       Hydra.Variables       Hydra.Variants

@@ -499,7 +499,8 @@           Packaging.entityMetadataDescription = (Just (Strings.concat2 "Source module for " (Packaging.unModuleName (Packaging.moduleName m)))),           Packaging.entityMetadataComments = [],           Packaging.entityMetadataSeeAlso = [],-          Packaging.entityMetadataLifecycle = Nothing})),+          Packaging.entityMetadataLifecycle = Nothing,+          Packaging.entityMetadataProvisions = []})),         Packaging.moduleDependencies = [           Packaging.ModuleDependency {             Packaging.moduleDependencyModule = modTypeNs,

@@ -173,6 +173,12 @@                         Core.Name "invalidPackageName",                         (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidPackageName t) (invalidPackageNameError cx input))),                       (+                        Core.Name "moduleInMultiplePackages",+                        (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorModuleInMultiplePackages t) (moduleInMultiplePackagesError cx input))),+                      (+                        Core.Name "nestedModuleName",+                        (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorNestedModuleName t) (nestedModuleNameError cx input))),+                      (                         Core.Name "undeclaredDependency",                         (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorUndeclaredDependency t) (undeclaredDependencyError cx input)))]         in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [@@ -201,6 +207,29 @@           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.ModuleInMultiplePackagesError+moduleInMultiplePackagesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesError 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 "firstPackage" DecodePackaging.packageName fieldMap cx) (\field_firstPackage -> Eithers.bind (ExtractCore.requireField "secondPackage" DecodePackaging.packageName fieldMap cx) (\field_secondPackage -> Right (ErrorPackaging.ModuleInMultiplePackagesError {+          ErrorPackaging.moduleInMultiplePackagesErrorModuleName = field_moduleName,+          ErrorPackaging.moduleInMultiplePackagesErrorFirstPackage = field_firstPackage,+          ErrorPackaging.moduleInMultiplePackagesErrorSecondPackage = field_secondPackage})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.ModuleInMultiplePackagesError")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.error.packaging.NestedModuleNameError+nestedModuleNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.NestedModuleNameError+nestedModuleNameError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "outer" DecodePackaging.moduleName fieldMap cx) (\field_outer -> Eithers.bind (ExtractCore.requireField "inner" DecodePackaging.moduleName fieldMap cx) (\field_inner -> Right (ErrorPackaging.NestedModuleNameError {+          ErrorPackaging.nestedModuleNameErrorOuter = field_outer,+          ErrorPackaging.nestedModuleNameErrorInner = field_inner}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.NestedModuleNameError")) (ExtractCore.stripWithDecodingError cx raw)  -- | Decoder for hydra.error.packaging.UndeclaredDependencyError undeclaredDependencyError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.UndeclaredDependencyError

@@ -96,11 +96,12 @@           Core.TermLiteral v1 -> case v1 of             Core.LiteralString v2 -> Right v2             _ -> Left (Errors.DecodingError "expected string literal")-          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_comments -> Eithers.bind (ExtractCore.requireField "seeAlso" (ExtractCore.decodeList entityReference) fieldMap cx) (\field_seeAlso -> Eithers.bind (ExtractCore.requireField "lifecycle" (ExtractCore.decodeMaybe lifecycleInfo) fieldMap cx) (\field_lifecycle -> Right (Packaging.EntityMetadata {+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_comments -> Eithers.bind (ExtractCore.requireField "seeAlso" (ExtractCore.decodeList entityReference) fieldMap cx) (\field_seeAlso -> Eithers.bind (ExtractCore.requireField "lifecycle" (ExtractCore.decodeMaybe lifecycleInfo) fieldMap cx) (\field_lifecycle -> Eithers.bind (ExtractCore.requireField "provisions" (ExtractCore.decodeList provision) fieldMap cx) (\field_provisions -> Right (Packaging.EntityMetadata {           Packaging.entityMetadataDescription = field_description,           Packaging.entityMetadataComments = field_comments,           Packaging.entityMetadataSeeAlso = field_seeAlso,-          Packaging.entityMetadataLifecycle = field_lifecycle}))))))+          Packaging.entityMetadataLifecycle = field_lifecycle,+          Packaging.entityMetadataProvisions = field_provisions})))))))       _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.EntityMetadata")) (ExtractCore.stripWithDecodingError cx raw)  -- | Decoder for hydra.packaging.EntityReference@@ -242,6 +243,44 @@           Packaging.primitiveDefinitionIsTotal = field_isTotal,           Packaging.primitiveDefinitionDefaultImplementation = field_defaultImplementation}))))))))       _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.PrimitiveDefinition")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.packaging.Provision+provision :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.Provision+provision cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "kind" provisionKind fieldMap cx) (\field_kind -> Eithers.bind (ExtractCore.requireField "statement" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_statement -> Right (Packaging.Provision {+          Packaging.provisionName = field_name,+          Packaging.provisionKind = field_kind,+          Packaging.provisionStatement = field_statement})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.Provision")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.packaging.ProvisionKind+provisionKind :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.ProvisionKind+provisionKind cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (+                        Core.Name "requirement",+                        (\input -> Eithers.map (\t -> Packaging.ProvisionKindRequirement) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "recommendation",+                        (\input -> Eithers.map (\t -> Packaging.ProvisionKindRecommendation) (ExtractCore.decodeUnit cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)  -- | Decoder for hydra.packaging.TermDefinition termDefinition :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.TermDefinition

@@ -21,68 +21,61 @@ import qualified Data.Scientific as Sci import Data.Void --- | Decoder for hydra.paths.SubtermAttribute-subtermAttribute :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermAttribute-subtermAttribute cx raw =+-- | Decoder for hydra.paths.LambdaVariableReference+lambdaVariableReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.LambdaVariableReference+lambdaVariableReference cx raw =     Eithers.either (\err -> Left err) (\stripped -> case stripped of       Core.TermRecord v0 ->         let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "path" subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "target" termAttribute fieldMap cx) (\field_target -> Right (Paths.SubtermAttribute {-          Paths.subtermAttributePath = field_path,-          Paths.subtermAttributeTarget = field_target}))))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermAttribute")) (ExtractCore.stripWithDecodingError cx raw)+        in (Eithers.bind (ExtractCore.requireField "variable" DecodeCore.name fieldMap cx) (\field_variable -> Eithers.bind (ExtractCore.requireField "boundByNode" termNodeId fieldMap cx) (\field_boundByNode -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Right (Paths.LambdaVariableReference {+          Paths.lambdaVariableReferenceVariable = field_variable,+          Paths.lambdaVariableReferenceBoundByNode = field_boundByNode,+          Paths.lambdaVariableReferenceType = field_type})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.LambdaVariableReference")) (ExtractCore.stripWithDecodingError cx raw) --- | Decoder for hydra.paths.SubtermEdge-subtermEdge :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermEdge-subtermEdge cx raw =+-- | Decoder for hydra.paths.LetVariableReference+letVariableReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.LetVariableReference+letVariableReference cx raw =     Eithers.either (\err -> Left err) (\stripped -> case stripped of       Core.TermRecord v0 ->         let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "path" subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "target" DecodeCore.name fieldMap cx) (\field_target -> Right (Paths.SubtermEdge {-          Paths.subtermEdgePath = field_path,-          Paths.subtermEdgeTarget = field_target}))))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermEdge")) (ExtractCore.stripWithDecodingError cx raw)+        in (Eithers.bind (ExtractCore.requireField "variable" DecodeCore.name fieldMap cx) (\field_variable -> Eithers.bind (ExtractCore.requireField "bindingNode" termNodeId fieldMap cx) (\field_bindingNode -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Right (Paths.LetVariableReference {+          Paths.letVariableReferenceVariable = field_variable,+          Paths.letVariableReferenceBindingNode = field_bindingNode,+          Paths.letVariableReferenceType = field_type})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.LetVariableReference")) (ExtractCore.stripWithDecodingError cx raw) --- | Decoder for hydra.paths.SubtermGraph-subtermGraph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermGraph-subtermGraph cx raw =+-- | Decoder for hydra.paths.NominalTypeReference+nominalTypeReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.NominalTypeReference+nominalTypeReference cx raw =     Eithers.either (\err -> Left err) (\stripped -> case stripped of       Core.TermRecord v0 ->         let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "nodes" (ExtractCore.decodeList subtermNode) fieldMap cx) (\field_nodes -> Right (Paths.SubtermGraph {-          Paths.subtermGraphNodes = field_nodes})))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermGraph")) (ExtractCore.stripWithDecodingError cx raw)+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (Paths.NominalTypeReference {+          Paths.nominalTypeReferenceName = field_name})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.NominalTypeReference")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.paths.PrimitiveReference+primitiveReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.PrimitiveReference+primitiveReference cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Right (Paths.PrimitiveReference {+          Paths.primitiveReferenceName = field_name,+          Paths.primitiveReferenceType = field_type}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.PrimitiveReference")) (ExtractCore.stripWithDecodingError cx raw)+ -- | Decoder for hydra.paths.SubtermLink subtermLink :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermLink subtermLink cx raw =     Eithers.either (\err -> Left err) (\stripped -> case stripped of-      Core.TermInject v0 ->-        let field = Core.injectionField v0-            fname = Core.fieldName field-            fterm = Core.fieldTerm field-            variantMap =-                    Maps.fromList [-                      (Core.Name "edge", (\input -> Eithers.map (\t -> Paths.SubtermLinkEdge t) (subtermEdge cx input))),-                      (Core.Name "property", (\input -> Eithers.map (\t -> Paths.SubtermLinkProperty t) (subtermProperty cx input))),-                      (Core.Name "attribute", (\input -> Eithers.map (\t -> Paths.SubtermLinkAttribute t) (subtermAttribute cx input)))]-        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [-          "no such field ",-          (Core.unName fname),-          " in union"]))) (\f -> f fterm))-      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)---- | Decoder for hydra.paths.SubtermNode-subtermNode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermNode-subtermNode cx raw =-    Eithers.either (\err -> Left err) (\stripped -> case stripped of       Core.TermRecord v0 ->         let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.typeScheme fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "links" (ExtractCore.decodeList subtermLink) fieldMap cx) (\field_links -> Right (Paths.SubtermNode {-          Paths.subtermNodeName = field_name,-          Paths.subtermNodeType = field_type,-          Paths.subtermNodeLinks = field_links})))))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermNode")) (ExtractCore.stripWithDecodingError cx raw)+        in (Eithers.bind (ExtractCore.requireField "step" subtermStep fieldMap cx) (\field_step -> Eithers.bind (ExtractCore.requireField "child" termNode fieldMap cx) (\field_child -> Right (Paths.SubtermLink {+          Paths.subtermLinkStep = field_step,+          Paths.subtermLinkChild = field_child}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermLink")) (ExtractCore.stripWithDecodingError cx raw)  -- | Decoder for hydra.paths.SubtermPath subtermPath :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermPath@@ -91,17 +84,6 @@       Core.TermWrap v0 -> Eithers.map (\b -> Paths.SubtermPath b) (ExtractCore.decodeList subtermStep cx (Core.wrappedTermBody v0))       _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) --- | Decoder for hydra.paths.SubtermProperty-subtermProperty :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermProperty-subtermProperty cx raw =-    Eithers.either (\err -> Left err) (\stripped -> case stripped of-      Core.TermRecord v0 ->-        let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "path" subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "target" DecodeCore.term fieldMap cx) (\field_target -> Right (Paths.SubtermProperty {-          Paths.subtermPropertyPath = field_path,-          Paths.subtermPropertyTarget = field_target}))))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermProperty")) (ExtractCore.stripWithDecodingError cx raw)- -- | Decoder for hydra.paths.SubtermStep subtermStep :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermStep subtermStep cx raw =@@ -144,17 +126,8 @@                             _ -> Left (Errors.DecodingError "expected int32 literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),                       (-                        Core.Name "mapKey",-                        (\input -> Eithers.map (\t -> Paths.SubtermStepMapKey t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of-                          Core.TermLiteral v1 -> case v1 of-                            Core.LiteralInteger v2 -> case v2 of-                              Core.IntegerValueInt32 v3 -> Right v3-                              _ -> Left (Errors.DecodingError "expected int32 value")-                            _ -> Left (Errors.DecodingError "expected int32 literal")-                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),-                      (-                        Core.Name "mapValue",-                        (\input -> Eithers.map (\t -> Paths.SubtermStepMapValue t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                        Core.Name "mapEntry",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepMapEntry t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of                           Core.TermLiteral v1 -> case v1 of                             Core.LiteralInteger v2 -> case v2 of                               Core.IntegerValueInt32 v3 -> Right v3@@ -189,67 +162,16 @@           " in union"]))) (\f -> f fterm))       _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) --- | Decoder for hydra.paths.SubtypeAttribute-subtypeAttribute :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeAttribute-subtypeAttribute cx raw =-    Eithers.either (\err -> Left err) (\stripped -> case stripped of-      Core.TermRecord v0 ->-        let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "path" subtypePath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "target" typeAttribute fieldMap cx) (\field_target -> Right (Paths.SubtypeAttribute {-          Paths.subtypeAttributePath = field_path,-          Paths.subtypeAttributeTarget = field_target}))))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeAttribute")) (ExtractCore.stripWithDecodingError cx raw)---- | Decoder for hydra.paths.SubtypeEdge-subtypeEdge :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeEdge-subtypeEdge cx raw =-    Eithers.either (\err -> Left err) (\stripped -> case stripped of-      Core.TermRecord v0 ->-        let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "path" subtypePath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "target" DecodeCore.name fieldMap cx) (\field_target -> Right (Paths.SubtypeEdge {-          Paths.subtypeEdgePath = field_path,-          Paths.subtypeEdgeTarget = field_target}))))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeEdge")) (ExtractCore.stripWithDecodingError cx raw)---- | Decoder for hydra.paths.SubtypeGraph-subtypeGraph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeGraph-subtypeGraph cx raw =-    Eithers.either (\err -> Left err) (\stripped -> case stripped of-      Core.TermRecord v0 ->-        let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "nodes" (ExtractCore.decodeList subtypeNode) fieldMap cx) (\field_nodes -> Right (Paths.SubtypeGraph {-          Paths.subtypeGraphNodes = field_nodes})))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeGraph")) (ExtractCore.stripWithDecodingError cx raw)- -- | Decoder for hydra.paths.SubtypeLink subtypeLink :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeLink subtypeLink cx raw =     Eithers.either (\err -> Left err) (\stripped -> case stripped of-      Core.TermInject v0 ->-        let field = Core.injectionField v0-            fname = Core.fieldName field-            fterm = Core.fieldTerm field-            variantMap =-                    Maps.fromList [-                      (Core.Name "edge", (\input -> Eithers.map (\t -> Paths.SubtypeLinkEdge t) (subtypeEdge cx input))),-                      (Core.Name "property", (\input -> Eithers.map (\t -> Paths.SubtypeLinkProperty t) (subtypeProperty cx input))),-                      (Core.Name "attribute", (\input -> Eithers.map (\t -> Paths.SubtypeLinkAttribute t) (subtypeAttribute cx input)))]-        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [-          "no such field ",-          (Core.unName fname),-          " in union"]))) (\f -> f fterm))-      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)---- | Decoder for hydra.paths.SubtypeNode-subtypeNode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeNode-subtypeNode cx raw =-    Eithers.either (\err -> Left err) (\stripped -> case stripped of       Core.TermRecord v0 ->         let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "links" (ExtractCore.decodeList subtypeLink) fieldMap cx) (\field_links -> Right (Paths.SubtypeNode {-          Paths.subtypeNodeName = field_name,-          Paths.subtypeNodeLinks = field_links}))))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeNode")) (ExtractCore.stripWithDecodingError cx raw)+        in (Eithers.bind (ExtractCore.requireField "step" subtypeStep fieldMap cx) (\field_step -> Eithers.bind (ExtractCore.requireField "child" typeNode fieldMap cx) (\field_child -> Right (Paths.SubtypeLink {+          Paths.subtypeLinkStep = field_step,+          Paths.subtypeLinkChild = field_child}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeLink")) (ExtractCore.stripWithDecodingError cx raw)  -- | Decoder for hydra.paths.SubtypePath subtypePath :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypePath@@ -258,17 +180,6 @@       Core.TermWrap v0 -> Eithers.map (\b -> Paths.SubtypePath b) (ExtractCore.decodeList subtypeStep cx (Core.wrappedTermBody v0))       _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) --- | Decoder for hydra.paths.SubtypeProperty-subtypeProperty :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeProperty-subtypeProperty cx raw =-    Eithers.either (\err -> Left err) (\stripped -> case stripped of-      Core.TermRecord v0 ->-        let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "path" subtypePath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "target" DecodeCore.type_ fieldMap cx) (\field_target -> Right (Paths.SubtypeProperty {-          Paths.subtypePropertyPath = field_path,-          Paths.subtypePropertyTarget = field_target}))))-      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeProperty")) (ExtractCore.stripWithDecodingError cx raw)- -- | Decoder for hydra.paths.SubtypeStep subtypeStep :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeStep subtypeStep cx raw =@@ -316,9 +227,9 @@           " in union"]))) (\f -> f fterm))       _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) --- | Decoder for hydra.paths.TermAttribute-termAttribute :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TermAttribute-termAttribute cx raw =+-- | Decoder for hydra.paths.TermAttributeLink+termAttributeLink :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TermAttributeLink+termAttributeLink cx raw =     Eithers.either (\err -> Left err) (\stripped -> case stripped of       Core.TermInject v0 ->         let field = Core.injectionField v0@@ -326,59 +237,241 @@             fterm = Core.fieldTerm field             variantMap =                     Maps.fromList [-                      (Core.Name "casesTypeName", (\input -> Eithers.map (\t -> Paths.TermAttributeCasesTypeName t) (DecodeCore.name cx input))),                       (+                        Core.Name "casesTypeName",+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkCasesTypeName t) (DecodeCore.name cx input))),+                      (                         Core.Name "injectTypeName",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeInjectTypeName t) (DecodeCore.name cx input))),+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkInjectTypeName t) (DecodeCore.name cx input))),                       (                         Core.Name "lambdaDomainGiven",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeLambdaDomainGiven t) (DecodeCore.type_ cx input))),+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkLambdaDomainGiven t) (DecodeCore.type_ cx input))),                       (                         Core.Name "lambdaParameter",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeLambdaParameter t) (DecodeCore.name cx input))),+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkLambdaParameter t) (DecodeCore.name cx input))),                       (                         Core.Name "letBindingTypeSchemeGiven",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeLetBindingTypeSchemeGiven t) (ExtractCore.decodePair DecodeCore.name DecodeCore.typeScheme cx input))),+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkLetBindingTypeSchemeGiven t) (ExtractCore.decodePair DecodeCore.name DecodeCore.typeScheme cx input))),+                      (Core.Name "literal", (\input -> Eithers.map (\t -> Paths.TermAttributeLinkLiteral t) (DecodeCore.literal cx input))),                       (                         Core.Name "projectFieldName",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeProjectFieldName t) (DecodeCore.name cx input))),+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkProjectFieldName t) (DecodeCore.name cx input))),                       (                         Core.Name "projectTypeName",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeProjectTypeName t) (DecodeCore.name cx input))),+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkProjectTypeName t) (DecodeCore.name cx input))),                       (                         Core.Name "recordTypeName",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeRecordTypeName t) (DecodeCore.name cx input))),+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkRecordTypeName t) (DecodeCore.name cx input))),                       (                         Core.Name "typeApplicationType",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeTypeApplicationType t) (DecodeCore.type_ cx input))),+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkTypeApplicationType t) (DecodeCore.type_ cx input))),                       (                         Core.Name "typeLambdaParameter",-                        (\input -> Eithers.map (\t -> Paths.TermAttributeTypeLambdaParameter t) (DecodeCore.name cx input))),-                      (Core.Name "wrapTypeName", (\input -> Eithers.map (\t -> Paths.TermAttributeWrapTypeName t) (DecodeCore.name cx input)))]+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkTypeLambdaParameter t) (DecodeCore.name cx input))),+                      (+                        Core.Name "unwrapTypeName",+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkUnwrapTypeName t) (DecodeCore.name cx input))),+                      (+                        Core.Name "wrapTypeName",+                        (\input -> Eithers.map (\t -> Paths.TermAttributeLinkWrapTypeName t) (DecodeCore.name cx input)))]         in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))       _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw) --- | Decoder for hydra.paths.TypeAttribute-typeAttribute :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeAttribute-typeAttribute cx raw =+-- | Decoder for hydra.paths.TermGraph+termGraph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TermGraph+termGraph cx raw =     Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "roots" (ExtractCore.decodeMap DecodeCore.name termNode) fieldMap cx) (\field_roots -> Right (Paths.TermGraph {+          Paths.termGraphRoots = field_roots})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TermGraph")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TermLink+termLink :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TermLink+termLink cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of       Core.TermInject v0 ->         let field = Core.injectionField v0             fname = Core.fieldName field             fterm = Core.fieldTerm field             variantMap =                     Maps.fromList [+                      (Core.Name "attribute", (\input -> Eithers.map (\t -> Paths.TermLinkAttribute t) (termAttributeLink cx input))),+                      (Core.Name "reference", (\input -> Eithers.map (\t -> Paths.TermLinkReference t) (termReferenceLink cx input))),+                      (Core.Name "subterm", (\input -> Eithers.map (\t -> Paths.TermLinkSubterm t) (subtermLink cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TermNode+termNode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TermNode+termNode cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "term" DecodeCore.term fieldMap cx) (\field_term -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "links" (ExtractCore.decodeList termLink) fieldMap cx) (\field_links -> Right (Paths.TermNode {+          Paths.termNodeTerm = field_term,+          Paths.termNodeType = field_type,+          Paths.termNodeLinks = field_links})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TermNode")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TermNodeId+termNodeId :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TermNodeId+termNodeId cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "root" DecodeCore.name fieldMap cx) (\field_root -> Eithers.bind (ExtractCore.requireField "path" subtermPath fieldMap cx) (\field_path -> Right (Paths.TermNodeId {+          Paths.termNodeIdRoot = field_root,+          Paths.termNodeIdPath = field_path}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TermNodeId")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TermReference+termReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TermReference+termReference cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Core.Name "lambda", (\input -> Eithers.map (\t -> Paths.TermReferenceLambda t) (lambdaVariableReference cx input))),+                      (Core.Name "let", (\input -> Eithers.map (\t -> Paths.TermReferenceLet t) (letVariableReference cx input))),+                      (Core.Name "primitive", (\input -> Eithers.map (\t -> Paths.TermReferencePrimitive t) (primitiveReference cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TermReferenceLink+termReferenceLink :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TermReferenceLink+termReferenceLink cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "step" subtermStep fieldMap cx) (\field_step -> Eithers.bind (ExtractCore.requireField "target" termReference fieldMap cx) (\field_target -> Right (Paths.TermReferenceLink {+          Paths.termReferenceLinkStep = field_step,+          Paths.termReferenceLinkTarget = field_target}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TermReferenceLink")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TypeAttributeLink+typeAttributeLink :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeAttributeLink+typeAttributeLink cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [                       (                         Core.Name "annotatedAnnotation",-                        (\input -> Eithers.map (\t -> Paths.TypeAttributeAnnotatedAnnotation t) (DecodeCore.term cx input))),+                        (\input -> Eithers.map (\t -> Paths.TypeAttributeLinkAnnotatedAnnotation t) (DecodeCore.term cx input))),                       (                         Core.Name "forallParameter",-                        (\input -> Eithers.map (\t -> Paths.TypeAttributeForallParameter t) (DecodeCore.name cx input)))]+                        (\input -> Eithers.map (\t -> Paths.TypeAttributeLinkForallParameter t) (DecodeCore.name cx input))),+                      (Core.Name "literal", (\input -> Eithers.map (\t -> Paths.TypeAttributeLinkLiteral t) (DecodeCore.literalType cx input)))]         in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))       _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TypeGraph+typeGraph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeGraph+typeGraph cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "roots" (ExtractCore.decodeMap DecodeCore.name typeNode) fieldMap cx) (\field_roots -> Right (Paths.TypeGraph {+          Paths.typeGraphRoots = field_roots})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TypeGraph")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TypeLink+typeLink :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeLink+typeLink cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Core.Name "attribute", (\input -> Eithers.map (\t -> Paths.TypeLinkAttribute t) (typeAttributeLink cx input))),+                      (Core.Name "reference", (\input -> Eithers.map (\t -> Paths.TypeLinkReference t) (typeReferenceLink cx input))),+                      (Core.Name "subtype", (\input -> Eithers.map (\t -> Paths.TypeLinkSubtype t) (subtypeLink cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TypeNode+typeNode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeNode+typeNode cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "links" (ExtractCore.decodeList typeLink) fieldMap cx) (\field_links -> Right (Paths.TypeNode {+          Paths.typeNodeType = field_type,+          Paths.typeNodeLinks = field_links}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TypeNode")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TypeNodeId+typeNodeId :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeNodeId+typeNodeId cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "root" DecodeCore.name fieldMap cx) (\field_root -> Eithers.bind (ExtractCore.requireField "path" subtypePath fieldMap cx) (\field_path -> Right (Paths.TypeNodeId {+          Paths.typeNodeIdRoot = field_root,+          Paths.typeNodeIdPath = field_path}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TypeNodeId")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TypeReference+typeReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeReference+typeReference cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Core.Name "nominal", (\input -> Eithers.map (\t -> Paths.TypeReferenceNominal t) (nominalTypeReference cx input))),+                      (Core.Name "variable", (\input -> Eithers.map (\t -> Paths.TypeReferenceVariable t) (typeVariableReference cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TypeReferenceLink+typeReferenceLink :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeReferenceLink+typeReferenceLink cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "step" subtypeStep fieldMap cx) (\field_step -> Eithers.bind (ExtractCore.requireField "target" typeReference fieldMap cx) (\field_target -> Right (Paths.TypeReferenceLink {+          Paths.typeReferenceLinkStep = field_step,+          Paths.typeReferenceLinkTarget = field_target}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TypeReferenceLink")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.paths.TypeVariableReference+typeVariableReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.TypeVariableReference+typeVariableReference cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "variable" DecodeCore.name fieldMap cx) (\field_variable -> Eithers.bind (ExtractCore.requireField "boundByNode" typeNodeId fieldMap cx) (\field_boundByNode -> Right (Paths.TypeVariableReference {+          Paths.typeVariableReferenceVariable = field_variable,+          Paths.typeVariableReferenceBoundByNode = field_boundByNode}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.TypeVariableReference")) (ExtractCore.stripWithDecodingError cx raw)

@@ -34,7 +34,10 @@                       (Core.Name "camel", (\input -> Eithers.map (\t -> Util.CaseConventionCamel) (ExtractCore.decodeUnit cx input))),                       (Core.Name "pascal", (\input -> Eithers.map (\t -> Util.CaseConventionPascal) (ExtractCore.decodeUnit cx input))),                       (Core.Name "lowerSnake", (\input -> Eithers.map (\t -> Util.CaseConventionLowerSnake) (ExtractCore.decodeUnit cx input))),-                      (Core.Name "upperSnake", (\input -> Eithers.map (\t -> Util.CaseConventionUpperSnake) (ExtractCore.decodeUnit cx input)))]+                      (Core.Name "upperSnake", (\input -> Eithers.map (\t -> Util.CaseConventionUpperSnake) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "upperDashed",+                        (\input -> Eithers.map (\t -> Util.CaseConventionUpperDashed) (ExtractCore.decodeUnit cx input)))]         in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),

@@ -1530,7 +1530,8 @@             (Packaging.unModuleName (Packaging.moduleName mod))])),           Packaging.entityMetadataComments = [],           Packaging.entityMetadataSeeAlso = [],-          Packaging.entityMetadataLifecycle = Nothing})),+          Packaging.entityMetadataLifecycle = Nothing,+          Packaging.entityMetadataProvisions = []})),         Packaging.moduleDependencies = (Lists.map (\ns -> Packaging.ModuleDependency {           Packaging.moduleDependencyModule = ns,           Packaging.moduleDependencyPackage = Nothing}) (Lists.concat2 [@@ -1713,7 +1714,9 @@     case typ of       Core.TypeAnnotated v0 -> decodeType (Core.annotatedTypeBody v0)       Core.TypeApplication v0 -> Core.TermApplication (Core.Application {-        Core.applicationFunction = (decodeType (Core.applicationTypeFunction v0)),+        Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {+          Core.typeApplicationTermBody = (decodeType (Core.applicationTypeFunction v0)),+          Core.typeApplicationTermType = (decoderFullResultType (Core.applicationTypeArgument v0))})),         Core.applicationArgument = (decodeType (Core.applicationTypeArgument v0))})       Core.TypeEither v0 -> decodeEitherType v0       Core.TypeForall v0 -> decodeForallType v0@@ -1749,7 +1752,9 @@     case typ of       Core.TypeAnnotated v0 -> decodeTypeNamed ename (Core.annotatedTypeBody v0) rtype       Core.TypeApplication v0 -> Core.TermApplication (Core.Application {-        Core.applicationFunction = (decodeType (Core.applicationTypeFunction v0)),+        Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {+          Core.typeApplicationTermBody = (decodeType (Core.applicationTypeFunction v0)),+          Core.typeApplicationTermType = (decoderFullResultType (Core.applicationTypeArgument v0))})),         Core.applicationArgument = (decodeType (Core.applicationTypeArgument v0))})       Core.TypeEither v0 -> decodeEitherType v0       Core.TypeForall v0 -> Core.TermLambda (Core.Lambda {

@@ -827,6 +827,24 @@         Core.fieldName = (Core.Name "invalidPackageName"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL injection for the moduleInMultiplePackages variant of hydra.error.packaging.InvalidPackageError+invalidPackageErrorModuleInMultiplePackages :: Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError+invalidPackageErrorModuleInMultiplePackages x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "moduleInMultiplePackages"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the nestedModuleName variant of hydra.error.packaging.InvalidPackageError+invalidPackageErrorNestedModuleName :: Typed.TypedTerm ErrorPackaging.NestedModuleNameError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError+invalidPackageErrorNestedModuleName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nestedModuleName"),+        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 =@@ -939,6 +957,195 @@         Core.Field {           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesError moduleName firstPackage secondPackage =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "firstPackage"),+          Core.fieldTerm = (Typed.unTypedTerm firstPackage)},+        Core.Field {+          Core.fieldName = (Core.Name "secondPackage"),+          Core.fieldTerm = (Typed.unTypedTerm secondPackage)}]}))++-- | DSL accessor for the firstPackage field of hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorFirstPackage :: Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError -> Typed.TypedTerm Packaging.PackageName+moduleInMultiplePackagesErrorFirstPackage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+        Core.projectionFieldName = (Core.Name "firstPackage")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorModuleInMultiplePackagesError :: Typed.TypedName ErrorPackaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorModuleInMultiplePackagesError =+    Typed.TypedName (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError")++-- | DSL accessor for the moduleName field of hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorModuleName :: Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError -> Typed.TypedTerm Packaging.ModuleName+moduleInMultiplePackagesErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the secondPackage field of hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorSecondPackage :: Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError -> Typed.TypedTerm Packaging.PackageName+moduleInMultiplePackagesErrorSecondPackage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+        Core.projectionFieldName = (Core.Name "secondPackage")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the firstPackage field of hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorWithFirstPackage :: Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorWithFirstPackage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+      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.ModuleInMultiplePackagesError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "firstPackage"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "secondPackage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+              Core.projectionFieldName = (Core.Name "secondPackage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the moduleName field of hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "firstPackage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+              Core.projectionFieldName = (Core.Name "firstPackage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "secondPackage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+              Core.projectionFieldName = (Core.Name "secondPackage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the secondPackage field of hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorWithSecondPackage :: Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm ErrorPackaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesErrorWithSecondPackage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+      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.ModuleInMultiplePackagesError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "firstPackage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+              Core.projectionFieldName = (Core.Name "firstPackage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "secondPackage"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.error.packaging.NestedModuleNameError+nestedModuleNameError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.NestedModuleNameError+nestedModuleNameError outer inner =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.NestedModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "outer"),+          Core.fieldTerm = (Typed.unTypedTerm outer)},+        Core.Field {+          Core.fieldName = (Core.Name "inner"),+          Core.fieldTerm = (Typed.unTypedTerm inner)}]}))++-- | DSL accessor for the inner field of hydra.error.packaging.NestedModuleNameError+nestedModuleNameErrorInner :: Typed.TypedTerm ErrorPackaging.NestedModuleNameError -> Typed.TypedTerm Packaging.ModuleName+nestedModuleNameErrorInner x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.NestedModuleNameError"),+        Core.projectionFieldName = (Core.Name "inner")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.error.packaging.NestedModuleNameError+nestedModuleNameErrorNestedModuleNameError :: Typed.TypedName ErrorPackaging.NestedModuleNameError+nestedModuleNameErrorNestedModuleNameError = Typed.TypedName (Core.Name "hydra.error.packaging.NestedModuleNameError")++-- | DSL accessor for the outer field of hydra.error.packaging.NestedModuleNameError+nestedModuleNameErrorOuter :: Typed.TypedTerm ErrorPackaging.NestedModuleNameError -> Typed.TypedTerm Packaging.ModuleName+nestedModuleNameErrorOuter x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.NestedModuleNameError"),+        Core.projectionFieldName = (Core.Name "outer")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the inner field of hydra.error.packaging.NestedModuleNameError+nestedModuleNameErrorWithInner :: Typed.TypedTerm ErrorPackaging.NestedModuleNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.NestedModuleNameError+nestedModuleNameErrorWithInner original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.NestedModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "outer"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.NestedModuleNameError"),+              Core.projectionFieldName = (Core.Name "outer")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inner"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the outer field of hydra.error.packaging.NestedModuleNameError+nestedModuleNameErrorWithOuter :: Typed.TypedTerm ErrorPackaging.NestedModuleNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.NestedModuleNameError+nestedModuleNameErrorWithOuter original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.NestedModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "outer"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "inner"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.NestedModuleNameError"),+              Core.projectionFieldName = (Core.Name "inner")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL constructor for hydra.error.packaging.UndeclaredDependencyError undeclaredDependencyError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError

@@ -92,6 +92,15 @@         Core.applicationArgument = (Typed.unTypedTerm arg0)})),       Core.applicationArgument = (Typed.unTypedTerm arg1)})) +-- | DSL reference to hydra.names.composeProvisionName+composeProvisionName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm String -> Typed.TypedTerm Core.Name+composeProvisionName arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.composeProvisionName")),+        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 =@@ -182,6 +191,13 @@           Core.applicationArgument = (Typed.unTypedTerm arg1)})),         Core.applicationArgument = (Typed.unTypedTerm arg2)})),       Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.names.nameToUpperDashed+nameToUpperDashed :: Typed.TypedTerm Core.Name -> Typed.TypedTerm String+nameToUpperDashed arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.nameToUpperDashed")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))  -- | DSL reference to hydra.names.normalTypeVariable normalTypeVariable :: Typed.TypedTerm Int -> Typed.TypedTerm Core.Name

@@ -119,8 +119,8 @@         Core.fieldTerm = Core.TermUnit}}))  -- | DSL constructor for hydra.packaging.EntityMetadata-entityMetadata :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [String] -> Typed.TypedTerm [Packaging.EntityReference] -> Typed.TypedTerm (Maybe Packaging.LifecycleInfo) -> Typed.TypedTerm Packaging.EntityMetadata-entityMetadata description comments seeAlso lifecycle =+entityMetadata :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [String] -> Typed.TypedTerm [Packaging.EntityReference] -> Typed.TypedTerm (Maybe Packaging.LifecycleInfo) -> Typed.TypedTerm [Packaging.Provision] -> Typed.TypedTerm Packaging.EntityMetadata+entityMetadata description comments seeAlso lifecycle provisions =     Typed.TypedTerm (Core.TermRecord (Core.Record {       Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),       Core.recordFields = [@@ -135,7 +135,10 @@           Core.fieldTerm = (Typed.unTypedTerm seeAlso)},         Core.Field {           Core.fieldName = (Core.Name "lifecycle"),-          Core.fieldTerm = (Typed.unTypedTerm lifecycle)}]}))+          Core.fieldTerm = (Typed.unTypedTerm lifecycle)},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Typed.unTypedTerm provisions)}]}))  -- | DSL accessor for the comments field of hydra.packaging.EntityMetadata entityMetadataComments :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm [String]@@ -168,6 +171,15 @@         Core.projectionFieldName = (Core.Name "lifecycle")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL accessor for the provisions field of hydra.packaging.EntityMetadata+entityMetadataProvisions :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm [Packaging.Provision]+entityMetadataProvisions x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+        Core.projectionFieldName = (Core.Name "provisions")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+ -- | DSL accessor for the seeAlso field of hydra.packaging.EntityMetadata entityMetadataSeeAlso :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm [Packaging.EntityReference] entityMetadataSeeAlso x =@@ -206,6 +218,13 @@             Core.applicationFunction = (Core.TermProject (Core.Projection {               Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),               Core.projectionFieldName = (Core.Name "lifecycle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "provisions")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL updater for the description field of hydra.packaging.EntityMetadata@@ -237,6 +256,13 @@             Core.applicationFunction = (Core.TermProject (Core.Projection {               Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),               Core.projectionFieldName = (Core.Name "lifecycle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "provisions")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL updater for the lifecycle field of hydra.packaging.EntityMetadata@@ -268,6 +294,51 @@             Core.applicationArgument = (Typed.unTypedTerm original)}))},         Core.Field {           Core.fieldName = (Core.Name "lifecycle"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "provisions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the provisions field of hydra.packaging.EntityMetadata+entityMetadataWithProvisions :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm [Packaging.Provision] -> Typed.TypedTerm Packaging.EntityMetadata+entityMetadataWithProvisions original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "comments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "comments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "seeAlso"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "seeAlso")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lifecycle"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "lifecycle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))  -- | DSL updater for the seeAlso field of hydra.packaging.EntityMetadata@@ -299,6 +370,13 @@             Core.applicationFunction = (Core.TermProject (Core.Projection {               Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),               Core.projectionFieldName = (Core.Name "lifecycle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "provisions")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL injection for the definition variant of hydra.packaging.EntityReference@@ -1347,6 +1425,147 @@               Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),               Core.projectionFieldName = (Core.Name "defaultImplementation")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.packaging.Provision+provision :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.ProvisionKind -> Typed.TypedTerm String -> Typed.TypedTerm Packaging.Provision+provision name kind statement =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Provision"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (Typed.unTypedTerm kind)},+        Core.Field {+          Core.fieldName = (Core.Name "statement"),+          Core.fieldTerm = (Typed.unTypedTerm statement)}]}))++-- | DSL accessor for the kind field of hydra.packaging.Provision+provisionKind :: Typed.TypedTerm Packaging.Provision -> Typed.TypedTerm Packaging.ProvisionKind+provisionKind x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+        Core.projectionFieldName = (Core.Name "kind")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.packaging.ProvisionKind+provisionKindProvisionKind :: Typed.TypedName Packaging.ProvisionKind+provisionKindProvisionKind = Typed.TypedName (Core.Name "hydra.packaging.ProvisionKind")++-- | DSL injection for the recommendation variant of hydra.packaging.ProvisionKind+provisionKindRecommendation :: Typed.TypedTerm Packaging.ProvisionKind+provisionKindRecommendation =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.ProvisionKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "recommendation"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the requirement variant of hydra.packaging.ProvisionKind+provisionKindRequirement :: Typed.TypedTerm Packaging.ProvisionKind+provisionKindRequirement =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.ProvisionKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "requirement"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL accessor for the name field of hydra.packaging.Provision+provisionName :: Typed.TypedTerm Packaging.Provision -> Typed.TypedTerm Core.Name+provisionName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.packaging.Provision+provisionProvision :: Typed.TypedName Packaging.Provision+provisionProvision = Typed.TypedName (Core.Name "hydra.packaging.Provision")++-- | DSL accessor for the statement field of hydra.packaging.Provision+provisionStatement :: Typed.TypedTerm Packaging.Provision -> Typed.TypedTerm String+provisionStatement x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+        Core.projectionFieldName = (Core.Name "statement")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the kind field of hydra.packaging.Provision+provisionWithKind :: Typed.TypedTerm Packaging.Provision -> Typed.TypedTerm Packaging.ProvisionKind -> Typed.TypedTerm Packaging.Provision+provisionWithKind original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Provision"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "statement"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+              Core.projectionFieldName = (Core.Name "statement")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.packaging.Provision+provisionWithName :: Typed.TypedTerm Packaging.Provision -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.Provision+provisionWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Provision"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+              Core.projectionFieldName = (Core.Name "kind")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "statement"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+              Core.projectionFieldName = (Core.Name "statement")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the statement field of hydra.packaging.Provision+provisionWithStatement :: Typed.TypedTerm Packaging.Provision -> Typed.TypedTerm String -> Typed.TypedTerm Packaging.Provision+provisionWithStatement original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Provision"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Provision"),+              Core.projectionFieldName = (Core.Name "kind")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "statement"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))  -- | DSL constructor for hydra.packaging.TermDefinition termDefinition :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm (Maybe Typing.TermSignature) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Packaging.TermDefinition

@@ -13,1269 +13,1750 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void---- | DSL constructor for hydra.paths.SubtermAttribute-subtermAttribute :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.TermAttribute -> Typed.TypedTerm Paths.SubtermAttribute-subtermAttribute path target =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermAttribute"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm path)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm target)}]}))---- | DSL accessor for the path field of hydra.paths.SubtermAttribute-subtermAttributePath :: Typed.TypedTerm Paths.SubtermAttribute -> Typed.TypedTerm Paths.SubtermPath-subtermAttributePath x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermAttribute"),-        Core.projectionFieldName = (Core.Name "path")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtermAttribute-subtermAttributeSubtermAttribute :: Typed.TypedName Paths.SubtermAttribute-subtermAttributeSubtermAttribute = Typed.TypedName (Core.Name "hydra.paths.SubtermAttribute")---- | DSL accessor for the target field of hydra.paths.SubtermAttribute-subtermAttributeTarget :: Typed.TypedTerm Paths.SubtermAttribute -> Typed.TypedTerm Paths.TermAttribute-subtermAttributeTarget x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermAttribute"),-        Core.projectionFieldName = (Core.Name "target")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL updater for the path field of hydra.paths.SubtermAttribute-subtermAttributeWithPath :: Typed.TypedTerm Paths.SubtermAttribute -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.SubtermAttribute-subtermAttributeWithPath original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermAttribute"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermAttribute"),-              Core.projectionFieldName = (Core.Name "target")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL updater for the target field of hydra.paths.SubtermAttribute-subtermAttributeWithTarget :: Typed.TypedTerm Paths.SubtermAttribute -> Typed.TypedTerm Paths.TermAttribute -> Typed.TypedTerm Paths.SubtermAttribute-subtermAttributeWithTarget original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermAttribute"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermAttribute"),-              Core.projectionFieldName = (Core.Name "path")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL constructor for hydra.paths.SubtermEdge-subtermEdge :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermEdge-subtermEdge path target =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm path)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm target)}]}))---- | DSL accessor for the path field of hydra.paths.SubtermEdge-subtermEdgePath :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermPath-subtermEdgePath x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),-        Core.projectionFieldName = (Core.Name "path")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL 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 Core.Name-subtermEdgeTarget x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),-        Core.projectionFieldName = (Core.Name "target")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL updater for the path field of hydra.paths.SubtermEdge-subtermEdgeWithPath :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.SubtermEdge-subtermEdgeWithPath original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),-              Core.projectionFieldName = (Core.Name "target")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL updater for the target field of hydra.paths.SubtermEdge-subtermEdgeWithTarget :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermEdge-subtermEdgeWithTarget original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),-              Core.projectionFieldName = (Core.Name "path")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL constructor for hydra.paths.SubtermGraph-subtermGraph :: Typed.TypedTerm [Paths.SubtermNode] -> Typed.TypedTerm Paths.SubtermGraph-subtermGraph nodes =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "nodes"),-          Core.fieldTerm = (Typed.unTypedTerm nodes)}]}))---- | DSL accessor for the nodes field of hydra.paths.SubtermGraph-subtermGraphNodes :: Typed.TypedTerm Paths.SubtermGraph -> Typed.TypedTerm [Paths.SubtermNode]-subtermGraphNodes x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"),-        Core.projectionFieldName = (Core.Name "nodes")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtermGraph-subtermGraphSubtermGraph :: Typed.TypedName Paths.SubtermGraph-subtermGraphSubtermGraph = Typed.TypedName (Core.Name "hydra.paths.SubtermGraph")---- | DSL updater for the nodes field of hydra.paths.SubtermGraph-subtermGraphWithNodes :: Typed.TypedTerm Paths.SubtermGraph -> Typed.TypedTerm [Paths.SubtermNode] -> Typed.TypedTerm Paths.SubtermGraph-subtermGraphWithNodes original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "nodes"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL injection for the attribute variant of hydra.paths.SubtermLink-subtermLinkAttribute :: Typed.TypedTerm Paths.SubtermAttribute -> Typed.TypedTerm Paths.SubtermLink-subtermLinkAttribute x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermLink"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "attribute"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the edge variant of hydra.paths.SubtermLink-subtermLinkEdge :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermLink-subtermLinkEdge x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermLink"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "edge"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the property variant of hydra.paths.SubtermLink-subtermLinkProperty :: Typed.TypedTerm Paths.SubtermProperty -> Typed.TypedTerm Paths.SubtermLink-subtermLinkProperty x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermLink"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "property"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL name token for hydra.paths.SubtermLink-subtermLinkSubtermLink :: Typed.TypedName Paths.SubtermLink-subtermLinkSubtermLink = Typed.TypedName (Core.Name "hydra.paths.SubtermLink")---- | DSL constructor for hydra.paths.SubtermNode-subtermNode :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm [Paths.SubtermLink] -> Typed.TypedTerm Paths.SubtermNode-subtermNode name type_ links =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (Typed.unTypedTerm name)},-        Core.Field {-          Core.fieldName = (Core.Name "type"),-          Core.fieldTerm = (Typed.unTypedTerm type_)},-        Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = (Typed.unTypedTerm links)}]}))---- | DSL accessor for the links field of hydra.paths.SubtermNode-subtermNodeLinks :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm [Paths.SubtermLink]-subtermNodeLinks x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-        Core.projectionFieldName = (Core.Name "links")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL accessor for the name field of hydra.paths.SubtermNode-subtermNodeName :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Core.Name-subtermNodeName x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-        Core.projectionFieldName = (Core.Name "name")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtermNode-subtermNodeSubtermNode :: Typed.TypedName Paths.SubtermNode-subtermNodeSubtermNode = Typed.TypedName (Core.Name "hydra.paths.SubtermNode")---- | DSL accessor for the type field of hydra.paths.SubtermNode-subtermNodeType :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Core.TypeScheme-subtermNodeType x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-        Core.projectionFieldName = (Core.Name "type")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL updater for the links field of hydra.paths.SubtermNode-subtermNodeWithLinks :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm [Paths.SubtermLink] -> Typed.TypedTerm Paths.SubtermNode-subtermNodeWithLinks original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-              Core.projectionFieldName = (Core.Name "name")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "type"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-              Core.projectionFieldName = (Core.Name "type")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL updater for the name field of hydra.paths.SubtermNode-subtermNodeWithName :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermNode-subtermNodeWithName original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "type"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-              Core.projectionFieldName = (Core.Name "type")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-              Core.projectionFieldName = (Core.Name "links")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL updater for the type field of hydra.paths.SubtermNode-subtermNodeWithType :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Paths.SubtermNode-subtermNodeWithType original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-              Core.projectionFieldName = (Core.Name "name")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "type"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),-              Core.projectionFieldName = (Core.Name "links")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL constructor for the hydra.paths.SubtermPath wrapper-subtermPath :: Typed.TypedTerm [Paths.SubtermStep] -> Typed.TypedTerm Paths.SubtermPath-subtermPath x =-    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {-      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),-      Core.wrappedTermBody = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtermPath-subtermPathSubtermPath :: Typed.TypedName Paths.SubtermPath-subtermPathSubtermPath = Typed.TypedName (Core.Name "hydra.paths.SubtermPath")---- | DSL constructor for hydra.paths.SubtermProperty-subtermProperty :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Paths.SubtermProperty-subtermProperty path target =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermProperty"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm path)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm target)}]}))---- | DSL accessor for the path field of hydra.paths.SubtermProperty-subtermPropertyPath :: Typed.TypedTerm Paths.SubtermProperty -> Typed.TypedTerm Paths.SubtermPath-subtermPropertyPath x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermProperty"),-        Core.projectionFieldName = (Core.Name "path")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtermProperty-subtermPropertySubtermProperty :: Typed.TypedName Paths.SubtermProperty-subtermPropertySubtermProperty = Typed.TypedName (Core.Name "hydra.paths.SubtermProperty")---- | DSL accessor for the target field of hydra.paths.SubtermProperty-subtermPropertyTarget :: Typed.TypedTerm Paths.SubtermProperty -> Typed.TypedTerm Core.Term-subtermPropertyTarget x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermProperty"),-        Core.projectionFieldName = (Core.Name "target")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL updater for the path field of hydra.paths.SubtermProperty-subtermPropertyWithPath :: Typed.TypedTerm Paths.SubtermProperty -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.SubtermProperty-subtermPropertyWithPath original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermProperty"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermProperty"),-              Core.projectionFieldName = (Core.Name "target")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL updater for the target field of hydra.paths.SubtermProperty-subtermPropertyWithTarget :: Typed.TypedTerm Paths.SubtermProperty -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Paths.SubtermProperty-subtermPropertyWithTarget original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermProperty"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermProperty"),-              Core.projectionFieldName = (Core.Name "path")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL injection for the annotatedAnnotation variant of hydra.paths.SubtermStep-subtermStepAnnotatedAnnotation :: Typed.TypedTerm Paths.SubtermStep-subtermStepAnnotatedAnnotation =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "annotatedAnnotation"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the annotatedBody variant of hydra.paths.SubtermStep-subtermStepAnnotatedBody :: Typed.TypedTerm Paths.SubtermStep-subtermStepAnnotatedBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "annotatedBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the applicationArgument variant of hydra.paths.SubtermStep-subtermStepApplicationArgument :: Typed.TypedTerm Paths.SubtermStep-subtermStepApplicationArgument =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "applicationArgument"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the applicationFunction variant of hydra.paths.SubtermStep-subtermStepApplicationFunction :: Typed.TypedTerm Paths.SubtermStep-subtermStepApplicationFunction =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "applicationFunction"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the casesCase variant of hydra.paths.SubtermStep-subtermStepCasesCase :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep-subtermStepCasesCase x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "casesCase"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the casesDefault variant of hydra.paths.SubtermStep-subtermStepCasesDefault :: Typed.TypedTerm Paths.SubtermStep-subtermStepCasesDefault =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "casesDefault"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the eitherLeft variant of hydra.paths.SubtermStep-subtermStepEitherLeft :: Typed.TypedTerm Paths.SubtermStep-subtermStepEitherLeft =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "eitherLeft"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the eitherRight variant of hydra.paths.SubtermStep-subtermStepEitherRight :: Typed.TypedTerm Paths.SubtermStep-subtermStepEitherRight =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "eitherRight"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the injectField variant of hydra.paths.SubtermStep-subtermStepInjectField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep-subtermStepInjectField x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "injectField"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the lambdaBody variant of hydra.paths.SubtermStep-subtermStepLambdaBody :: Typed.TypedTerm Paths.SubtermStep-subtermStepLambdaBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "lambdaBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the letBinding variant of hydra.paths.SubtermStep-subtermStepLetBinding :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep-subtermStepLetBinding x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "letBinding"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the letBody variant of hydra.paths.SubtermStep-subtermStepLetBody :: Typed.TypedTerm Paths.SubtermStep-subtermStepLetBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "letBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the listElement variant of hydra.paths.SubtermStep-subtermStepListElement :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep-subtermStepListElement x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "listElement"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the mapKey variant of hydra.paths.SubtermStep-subtermStepMapKey :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep-subtermStepMapKey x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "mapKey"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the mapValue variant of hydra.paths.SubtermStep-subtermStepMapValue :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep-subtermStepMapValue x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "mapValue"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the optionalGiven variant of hydra.paths.SubtermStep-subtermStepOptionalGiven :: Typed.TypedTerm Paths.SubtermStep-subtermStepOptionalGiven =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "optionalGiven"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the pairFirst variant of hydra.paths.SubtermStep-subtermStepPairFirst :: Typed.TypedTerm Paths.SubtermStep-subtermStepPairFirst =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "pairFirst"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the pairSecond variant of hydra.paths.SubtermStep-subtermStepPairSecond :: Typed.TypedTerm Paths.SubtermStep-subtermStepPairSecond =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "pairSecond"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the recordField variant of hydra.paths.SubtermStep-subtermStepRecordField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep-subtermStepRecordField x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "recordField"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the setElement variant of hydra.paths.SubtermStep-subtermStepSetElement :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep-subtermStepSetElement x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "setElement"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL name token for hydra.paths.SubtermStep-subtermStepSubtermStep :: Typed.TypedName Paths.SubtermStep-subtermStepSubtermStep = Typed.TypedName (Core.Name "hydra.paths.SubtermStep")---- | DSL injection for the typeApplicationBody variant of hydra.paths.SubtermStep-subtermStepTypeApplicationBody :: Typed.TypedTerm Paths.SubtermStep-subtermStepTypeApplicationBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "typeApplicationBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the typeLambdaBody variant of hydra.paths.SubtermStep-subtermStepTypeLambdaBody :: Typed.TypedTerm Paths.SubtermStep-subtermStepTypeLambdaBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "typeLambdaBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the wrapBody variant of hydra.paths.SubtermStep-subtermStepWrapBody :: Typed.TypedTerm Paths.SubtermStep-subtermStepWrapBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "wrapBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL constructor for hydra.paths.SubtypeAttribute-subtypeAttribute :: Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.TypeAttribute -> Typed.TypedTerm Paths.SubtypeAttribute-subtypeAttribute path target =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm path)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm target)}]}))---- | DSL accessor for the path field of hydra.paths.SubtypeAttribute-subtypeAttributePath :: Typed.TypedTerm Paths.SubtypeAttribute -> Typed.TypedTerm Paths.SubtypePath-subtypeAttributePath x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),-        Core.projectionFieldName = (Core.Name "path")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtypeAttribute-subtypeAttributeSubtypeAttribute :: Typed.TypedName Paths.SubtypeAttribute-subtypeAttributeSubtypeAttribute = Typed.TypedName (Core.Name "hydra.paths.SubtypeAttribute")---- | DSL accessor for the target field of hydra.paths.SubtypeAttribute-subtypeAttributeTarget :: Typed.TypedTerm Paths.SubtypeAttribute -> Typed.TypedTerm Paths.TypeAttribute-subtypeAttributeTarget x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),-        Core.projectionFieldName = (Core.Name "target")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL updater for the path field of hydra.paths.SubtypeAttribute-subtypeAttributeWithPath :: Typed.TypedTerm Paths.SubtypeAttribute -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.SubtypeAttribute-subtypeAttributeWithPath original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),-              Core.projectionFieldName = (Core.Name "target")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL updater for the target field of hydra.paths.SubtypeAttribute-subtypeAttributeWithTarget :: Typed.TypedTerm Paths.SubtypeAttribute -> Typed.TypedTerm Paths.TypeAttribute -> Typed.TypedTerm Paths.SubtypeAttribute-subtypeAttributeWithTarget original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),-              Core.projectionFieldName = (Core.Name "path")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL constructor for hydra.paths.SubtypeEdge-subtypeEdge :: Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeEdge-subtypeEdge path target =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm path)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm target)}]}))---- | DSL accessor for the path field of hydra.paths.SubtypeEdge-subtypeEdgePath :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypePath-subtypeEdgePath x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),-        Core.projectionFieldName = (Core.Name "path")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL 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 Core.Name-subtypeEdgeTarget x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),-        Core.projectionFieldName = (Core.Name "target")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL updater for the path field of hydra.paths.SubtypeEdge-subtypeEdgeWithPath :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.SubtypeEdge-subtypeEdgeWithPath original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),-              Core.projectionFieldName = (Core.Name "target")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL updater for the target field of hydra.paths.SubtypeEdge-subtypeEdgeWithTarget :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeEdge-subtypeEdgeWithTarget original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),-              Core.projectionFieldName = (Core.Name "path")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL constructor for hydra.paths.SubtypeGraph-subtypeGraph :: Typed.TypedTerm [Paths.SubtypeNode] -> Typed.TypedTerm Paths.SubtypeGraph-subtypeGraph nodes =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "nodes"),-          Core.fieldTerm = (Typed.unTypedTerm nodes)}]}))---- | DSL accessor for the nodes field of hydra.paths.SubtypeGraph-subtypeGraphNodes :: Typed.TypedTerm Paths.SubtypeGraph -> Typed.TypedTerm [Paths.SubtypeNode]-subtypeGraphNodes x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"),-        Core.projectionFieldName = (Core.Name "nodes")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtypeGraph-subtypeGraphSubtypeGraph :: Typed.TypedName Paths.SubtypeGraph-subtypeGraphSubtypeGraph = Typed.TypedName (Core.Name "hydra.paths.SubtypeGraph")---- | DSL updater for the nodes field of hydra.paths.SubtypeGraph-subtypeGraphWithNodes :: Typed.TypedTerm Paths.SubtypeGraph -> Typed.TypedTerm [Paths.SubtypeNode] -> Typed.TypedTerm Paths.SubtypeGraph-subtypeGraphWithNodes original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "nodes"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL injection for the attribute variant of hydra.paths.SubtypeLink-subtypeLinkAttribute :: Typed.TypedTerm Paths.SubtypeAttribute -> Typed.TypedTerm Paths.SubtypeLink-subtypeLinkAttribute x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "attribute"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the edge variant of hydra.paths.SubtypeLink-subtypeLinkEdge :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypeLink-subtypeLinkEdge x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "edge"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the property variant of hydra.paths.SubtypeLink-subtypeLinkProperty :: Typed.TypedTerm Paths.SubtypeProperty -> Typed.TypedTerm Paths.SubtypeLink-subtypeLinkProperty x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "property"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL name token for hydra.paths.SubtypeLink-subtypeLinkSubtypeLink :: Typed.TypedName Paths.SubtypeLink-subtypeLinkSubtypeLink = Typed.TypedName (Core.Name "hydra.paths.SubtypeLink")---- | DSL constructor for hydra.paths.SubtypeNode-subtypeNode :: Typed.TypedTerm Core.Name -> Typed.TypedTerm [Paths.SubtypeLink] -> Typed.TypedTerm Paths.SubtypeNode-subtypeNode name links =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (Typed.unTypedTerm name)},-        Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = (Typed.unTypedTerm links)}]}))---- | DSL accessor for the links field of hydra.paths.SubtypeNode-subtypeNodeLinks :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm [Paths.SubtypeLink]-subtypeNodeLinks x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),-        Core.projectionFieldName = (Core.Name "links")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL accessor for the name field of hydra.paths.SubtypeNode-subtypeNodeName :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Core.Name-subtypeNodeName x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),-        Core.projectionFieldName = (Core.Name "name")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtypeNode-subtypeNodeSubtypeNode :: Typed.TypedName Paths.SubtypeNode-subtypeNodeSubtypeNode = Typed.TypedName (Core.Name "hydra.paths.SubtypeNode")---- | DSL updater for the links field of hydra.paths.SubtypeNode-subtypeNodeWithLinks :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm [Paths.SubtypeLink] -> Typed.TypedTerm Paths.SubtypeNode-subtypeNodeWithLinks original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),-              Core.projectionFieldName = (Core.Name "name")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL updater for the name field of hydra.paths.SubtypeNode-subtypeNodeWithName :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeNode-subtypeNodeWithName original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),-              Core.projectionFieldName = (Core.Name "links")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL constructor for the hydra.paths.SubtypePath wrapper-subtypePath :: Typed.TypedTerm [Paths.SubtypeStep] -> Typed.TypedTerm Paths.SubtypePath-subtypePath x =-    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {-      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),-      Core.wrappedTermBody = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtypePath-subtypePathSubtypePath :: Typed.TypedName Paths.SubtypePath-subtypePathSubtypePath = Typed.TypedName (Core.Name "hydra.paths.SubtypePath")---- | DSL constructor for hydra.paths.SubtypeProperty-subtypeProperty :: Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.SubtypeProperty-subtypeProperty path target =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeProperty"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm path)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm target)}]}))---- | DSL accessor for the path field of hydra.paths.SubtypeProperty-subtypePropertyPath :: Typed.TypedTerm Paths.SubtypeProperty -> Typed.TypedTerm Paths.SubtypePath-subtypePropertyPath x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeProperty"),-        Core.projectionFieldName = (Core.Name "path")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL name token for hydra.paths.SubtypeProperty-subtypePropertySubtypeProperty :: Typed.TypedName Paths.SubtypeProperty-subtypePropertySubtypeProperty = Typed.TypedName (Core.Name "hydra.paths.SubtypeProperty")---- | DSL accessor for the target field of hydra.paths.SubtypeProperty-subtypePropertyTarget :: Typed.TypedTerm Paths.SubtypeProperty -> Typed.TypedTerm Core.Type-subtypePropertyTarget x =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermProject (Core.Projection {-        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeProperty"),-        Core.projectionFieldName = (Core.Name "target")})),-      Core.applicationArgument = (Typed.unTypedTerm x)}))---- | DSL updater for the path field of hydra.paths.SubtypeProperty-subtypePropertyWithPath :: Typed.TypedTerm Paths.SubtypeProperty -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.SubtypeProperty-subtypePropertyWithPath original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeProperty"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeProperty"),-              Core.projectionFieldName = (Core.Name "target")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))---- | DSL updater for the target field of hydra.paths.SubtypeProperty-subtypePropertyWithTarget :: Typed.TypedTerm Paths.SubtypeProperty -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.SubtypeProperty-subtypePropertyWithTarget original newVal =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeProperty"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (Core.TermApplication (Core.Application {-            Core.applicationFunction = (Core.TermProject (Core.Projection {-              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeProperty"),-              Core.projectionFieldName = (Core.Name "path")})),-            Core.applicationArgument = (Typed.unTypedTerm original)}))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL injection for the annotatedBody variant of hydra.paths.SubtypeStep-subtypeStepAnnotatedBody :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepAnnotatedBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "annotatedBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the applicationArgument variant of hydra.paths.SubtypeStep-subtypeStepApplicationArgument :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepApplicationArgument =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "applicationArgument"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the applicationFunction variant of hydra.paths.SubtypeStep-subtypeStepApplicationFunction :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepApplicationFunction =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "applicationFunction"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the effectValue variant of hydra.paths.SubtypeStep-subtypeStepEffectValue :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepEffectValue =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "effectValue"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the eitherLeft variant of hydra.paths.SubtypeStep-subtypeStepEitherLeft :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepEitherLeft =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "eitherLeft"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the eitherRight variant of hydra.paths.SubtypeStep-subtypeStepEitherRight :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepEitherRight =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "eitherRight"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the forallBody variant of hydra.paths.SubtypeStep-subtypeStepForallBody :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepForallBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "forallBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the functionCodomain variant of hydra.paths.SubtypeStep-subtypeStepFunctionCodomain :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepFunctionCodomain =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "functionCodomain"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the functionDomain variant of hydra.paths.SubtypeStep-subtypeStepFunctionDomain :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepFunctionDomain =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "functionDomain"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the listElement variant of hydra.paths.SubtypeStep-subtypeStepListElement :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepListElement =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "listElement"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the mapKeys variant of hydra.paths.SubtypeStep-subtypeStepMapKeys :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepMapKeys =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "mapKeys"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the mapValues variant of hydra.paths.SubtypeStep-subtypeStepMapValues :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepMapValues =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "mapValues"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the optionalElement variant of hydra.paths.SubtypeStep-subtypeStepOptionalElement :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepOptionalElement =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "optionalElement"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the pairFirst variant of hydra.paths.SubtypeStep-subtypeStepPairFirst :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepPairFirst =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "pairFirst"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the pairSecond variant of hydra.paths.SubtypeStep-subtypeStepPairSecond :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepPairSecond =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "pairSecond"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the recordField variant of hydra.paths.SubtypeStep-subtypeStepRecordField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeStep-subtypeStepRecordField x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "recordField"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the setElement variant of hydra.paths.SubtypeStep-subtypeStepSetElement :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepSetElement =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "setElement"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL 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-subtypeStepUnionField x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "unionField"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the wrapBody variant of hydra.paths.SubtypeStep-subtypeStepWrapBody :: Typed.TypedTerm Paths.SubtypeStep-subtypeStepWrapBody =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "wrapBody"),-        Core.fieldTerm = Core.TermUnit}}))---- | DSL injection for the casesTypeName variant of hydra.paths.TermAttribute-termAttributeCasesTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute-termAttributeCasesTypeName x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "casesTypeName"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the injectTypeName variant of hydra.paths.TermAttribute-termAttributeInjectTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute-termAttributeInjectTypeName x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "injectTypeName"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the lambdaDomainGiven variant of hydra.paths.TermAttribute-termAttributeLambdaDomainGiven :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TermAttribute-termAttributeLambdaDomainGiven x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "lambdaDomainGiven"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the lambdaParameter variant of hydra.paths.TermAttribute-termAttributeLambdaParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute-termAttributeLambdaParameter x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "lambdaParameter"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the letBindingTypeSchemeGiven variant of hydra.paths.TermAttribute-termAttributeLetBindingTypeSchemeGiven :: Typed.TypedTerm (Core.Name, Core.TypeScheme) -> Typed.TypedTerm Paths.TermAttribute-termAttributeLetBindingTypeSchemeGiven x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "letBindingTypeSchemeGiven"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the projectFieldName variant of hydra.paths.TermAttribute-termAttributeProjectFieldName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute-termAttributeProjectFieldName x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "projectFieldName"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the projectTypeName variant of hydra.paths.TermAttribute-termAttributeProjectTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute-termAttributeProjectTypeName x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "projectTypeName"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the recordTypeName variant of hydra.paths.TermAttribute-termAttributeRecordTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute-termAttributeRecordTypeName x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "recordTypeName"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL name token for hydra.paths.TermAttribute-termAttributeTermAttribute :: Typed.TypedName Paths.TermAttribute-termAttributeTermAttribute = Typed.TypedName (Core.Name "hydra.paths.TermAttribute")---- | DSL injection for the typeApplicationType variant of hydra.paths.TermAttribute-termAttributeTypeApplicationType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TermAttribute-termAttributeTypeApplicationType x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "typeApplicationType"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the typeLambdaParameter variant of hydra.paths.TermAttribute-termAttributeTypeLambdaParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute-termAttributeTypeLambdaParameter x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "typeLambdaParameter"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the wrapTypeName variant of hydra.paths.TermAttribute-termAttributeWrapTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute-termAttributeWrapTypeName x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "wrapTypeName"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the annotatedAnnotation variant of hydra.paths.TypeAttribute-typeAttributeAnnotatedAnnotation :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Paths.TypeAttribute-typeAttributeAnnotatedAnnotation x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "annotatedAnnotation"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL injection for the forallParameter variant of hydra.paths.TypeAttribute-typeAttributeForallParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeAttribute-typeAttributeForallParameter x =-    Typed.TypedTerm (Core.TermInject (Core.Injection {-      Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttribute"),-      Core.injectionField = Core.Field {-        Core.fieldName = (Core.Name "forallParameter"),-        Core.fieldTerm = (Typed.unTypedTerm x)}}))---- | DSL name token for hydra.paths.TypeAttribute-typeAttributeTypeAttribute :: Typed.TypedName Paths.TypeAttribute-typeAttributeTypeAttribute = Typed.TypedName (Core.Name "hydra.paths.TypeAttribute")+import qualified Data.Map as M++-- | DSL constructor for hydra.paths.LambdaVariableReference+lambdaVariableReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.LambdaVariableReference+lambdaVariableReference variable boundByNode type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Typed.unTypedTerm variable)},+        Core.Field {+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (Typed.unTypedTerm boundByNode)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))++-- | DSL accessor for the boundByNode field of hydra.paths.LambdaVariableReference+lambdaVariableReferenceBoundByNode :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Paths.TermNodeId+lambdaVariableReferenceBoundByNode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+        Core.projectionFieldName = (Core.Name "boundByNode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.LambdaVariableReference+lambdaVariableReferenceLambdaVariableReference :: Typed.TypedName Paths.LambdaVariableReference+lambdaVariableReferenceLambdaVariableReference = Typed.TypedName (Core.Name "hydra.paths.LambdaVariableReference")++-- | DSL accessor for the type field of hydra.paths.LambdaVariableReference+lambdaVariableReferenceType :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Core.Type+lambdaVariableReferenceType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the variable field of hydra.paths.LambdaVariableReference+lambdaVariableReferenceVariable :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Core.Name+lambdaVariableReferenceVariable x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+        Core.projectionFieldName = (Core.Name "variable")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the boundByNode field of hydra.paths.LambdaVariableReference+lambdaVariableReferenceWithBoundByNode :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Paths.LambdaVariableReference+lambdaVariableReferenceWithBoundByNode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+              Core.projectionFieldName = (Core.Name "variable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the type field of hydra.paths.LambdaVariableReference+lambdaVariableReferenceWithType :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.LambdaVariableReference+lambdaVariableReferenceWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+              Core.projectionFieldName = (Core.Name "variable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+              Core.projectionFieldName = (Core.Name "boundByNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the variable field of hydra.paths.LambdaVariableReference+lambdaVariableReferenceWithVariable :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.LambdaVariableReference+lambdaVariableReferenceWithVariable original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+              Core.projectionFieldName = (Core.Name "boundByNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.paths.LetVariableReference+letVariableReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.LetVariableReference+letVariableReference variable bindingNode type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Typed.unTypedTerm variable)},+        Core.Field {+          Core.fieldName = (Core.Name "bindingNode"),+          Core.fieldTerm = (Typed.unTypedTerm bindingNode)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))++-- | DSL accessor for the bindingNode field of hydra.paths.LetVariableReference+letVariableReferenceBindingNode :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Paths.TermNodeId+letVariableReferenceBindingNode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+        Core.projectionFieldName = (Core.Name "bindingNode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.LetVariableReference+letVariableReferenceLetVariableReference :: Typed.TypedName Paths.LetVariableReference+letVariableReferenceLetVariableReference = Typed.TypedName (Core.Name "hydra.paths.LetVariableReference")++-- | DSL accessor for the type field of hydra.paths.LetVariableReference+letVariableReferenceType :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Core.Type+letVariableReferenceType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the variable field of hydra.paths.LetVariableReference+letVariableReferenceVariable :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Core.Name+letVariableReferenceVariable x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+        Core.projectionFieldName = (Core.Name "variable")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the bindingNode field of hydra.paths.LetVariableReference+letVariableReferenceWithBindingNode :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Paths.LetVariableReference+letVariableReferenceWithBindingNode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+              Core.projectionFieldName = (Core.Name "variable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bindingNode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the type field of hydra.paths.LetVariableReference+letVariableReferenceWithType :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.LetVariableReference+letVariableReferenceWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+              Core.projectionFieldName = (Core.Name "variable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bindingNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+              Core.projectionFieldName = (Core.Name "bindingNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the variable field of hydra.paths.LetVariableReference+letVariableReferenceWithVariable :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.LetVariableReference+letVariableReferenceWithVariable original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "bindingNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+              Core.projectionFieldName = (Core.Name "bindingNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.paths.NominalTypeReference+nominalTypeReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.NominalTypeReference+nominalTypeReference name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.NominalTypeReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.paths.NominalTypeReference+nominalTypeReferenceName :: Typed.TypedTerm Paths.NominalTypeReference -> Typed.TypedTerm Core.Name+nominalTypeReferenceName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.NominalTypeReference"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.NominalTypeReference+nominalTypeReferenceNominalTypeReference :: Typed.TypedName Paths.NominalTypeReference+nominalTypeReferenceNominalTypeReference = Typed.TypedName (Core.Name "hydra.paths.NominalTypeReference")++-- | DSL updater for the name field of hydra.paths.NominalTypeReference+nominalTypeReferenceWithName :: Typed.TypedTerm Paths.NominalTypeReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.NominalTypeReference+nominalTypeReferenceWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.NominalTypeReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.paths.PrimitiveReference+primitiveReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.PrimitiveReference+primitiveReference name type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.PrimitiveReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))++-- | DSL accessor for the name field of hydra.paths.PrimitiveReference+primitiveReferenceName :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Core.Name+primitiveReferenceName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.PrimitiveReference"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.PrimitiveReference+primitiveReferencePrimitiveReference :: Typed.TypedName Paths.PrimitiveReference+primitiveReferencePrimitiveReference = Typed.TypedName (Core.Name "hydra.paths.PrimitiveReference")++-- | DSL accessor for the type field of hydra.paths.PrimitiveReference+primitiveReferenceType :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Core.Type+primitiveReferenceType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.PrimitiveReference"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.paths.PrimitiveReference+primitiveReferenceWithName :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.PrimitiveReference+primitiveReferenceWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.PrimitiveReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.PrimitiveReference"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the type field of hydra.paths.PrimitiveReference+primitiveReferenceWithType :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.PrimitiveReference+primitiveReferenceWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.PrimitiveReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.PrimitiveReference"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.paths.SubtermLink+subtermLink :: Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Paths.SubtermLink+subtermLink step child =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm step)},+        Core.Field {+          Core.fieldName = (Core.Name "child"),+          Core.fieldTerm = (Typed.unTypedTerm child)}]}))++-- | DSL accessor for the child field of hydra.paths.SubtermLink+subtermLinkChild :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.TermNode+subtermLinkChild x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermLink"),+        Core.projectionFieldName = (Core.Name "child")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the step field of hydra.paths.SubtermLink+subtermLinkStep :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.SubtermStep+subtermLinkStep x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermLink"),+        Core.projectionFieldName = (Core.Name "step")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.SubtermLink+subtermLinkSubtermLink :: Typed.TypedName Paths.SubtermLink+subtermLinkSubtermLink = Typed.TypedName (Core.Name "hydra.paths.SubtermLink")++-- | DSL updater for the child field of hydra.paths.SubtermLink+subtermLinkWithChild :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Paths.SubtermLink+subtermLinkWithChild original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermLink"),+              Core.projectionFieldName = (Core.Name "step")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "child"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the step field of hydra.paths.SubtermLink+subtermLinkWithStep :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Paths.SubtermLink+subtermLinkWithStep original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "child"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermLink"),+              Core.projectionFieldName = (Core.Name "child")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.paths.SubtermPath wrapper+subtermPath :: Typed.TypedTerm [Paths.SubtermStep] -> Typed.TypedTerm Paths.SubtermPath+subtermPath x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.SubtermPath+subtermPathSubtermPath :: Typed.TypedName Paths.SubtermPath+subtermPathSubtermPath = Typed.TypedName (Core.Name "hydra.paths.SubtermPath")++-- | DSL injection for the annotatedAnnotation variant of hydra.paths.SubtermStep+subtermStepAnnotatedAnnotation :: Typed.TypedTerm Paths.SubtermStep+subtermStepAnnotatedAnnotation =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotatedAnnotation"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the annotatedBody variant of hydra.paths.SubtermStep+subtermStepAnnotatedBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepAnnotatedBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotatedBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the applicationArgument variant of hydra.paths.SubtermStep+subtermStepApplicationArgument :: Typed.TypedTerm Paths.SubtermStep+subtermStepApplicationArgument =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "applicationArgument"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the applicationFunction variant of hydra.paths.SubtermStep+subtermStepApplicationFunction :: Typed.TypedTerm Paths.SubtermStep+subtermStepApplicationFunction =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "applicationFunction"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the casesCase variant of hydra.paths.SubtermStep+subtermStepCasesCase :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep+subtermStepCasesCase x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "casesCase"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the casesDefault variant of hydra.paths.SubtermStep+subtermStepCasesDefault :: Typed.TypedTerm Paths.SubtermStep+subtermStepCasesDefault =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "casesDefault"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the eitherLeft variant of hydra.paths.SubtermStep+subtermStepEitherLeft :: Typed.TypedTerm Paths.SubtermStep+subtermStepEitherLeft =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "eitherLeft"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the eitherRight variant of hydra.paths.SubtermStep+subtermStepEitherRight :: Typed.TypedTerm Paths.SubtermStep+subtermStepEitherRight =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "eitherRight"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the injectField variant of hydra.paths.SubtermStep+subtermStepInjectField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep+subtermStepInjectField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "injectField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the lambdaBody variant of hydra.paths.SubtermStep+subtermStepLambdaBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepLambdaBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lambdaBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the letBinding variant of hydra.paths.SubtermStep+subtermStepLetBinding :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep+subtermStepLetBinding x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "letBinding"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the letBody variant of hydra.paths.SubtermStep+subtermStepLetBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepLetBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "letBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the listElement variant of hydra.paths.SubtermStep+subtermStepListElement :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep+subtermStepListElement x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "listElement"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the mapEntry variant of hydra.paths.SubtermStep+subtermStepMapEntry :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep+subtermStepMapEntry x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapEntry"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the optionalGiven variant of hydra.paths.SubtermStep+subtermStepOptionalGiven :: Typed.TypedTerm Paths.SubtermStep+subtermStepOptionalGiven =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "optionalGiven"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the pairFirst variant of hydra.paths.SubtermStep+subtermStepPairFirst :: Typed.TypedTerm Paths.SubtermStep+subtermStepPairFirst =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pairFirst"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the pairSecond variant of hydra.paths.SubtermStep+subtermStepPairSecond :: Typed.TypedTerm Paths.SubtermStep+subtermStepPairSecond =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pairSecond"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the recordField variant of hydra.paths.SubtermStep+subtermStepRecordField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep+subtermStepRecordField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "recordField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the setElement variant of hydra.paths.SubtermStep+subtermStepSetElement :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep+subtermStepSetElement x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "setElement"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.paths.SubtermStep+subtermStepSubtermStep :: Typed.TypedName Paths.SubtermStep+subtermStepSubtermStep = Typed.TypedName (Core.Name "hydra.paths.SubtermStep")++-- | DSL injection for the typeApplicationBody variant of hydra.paths.SubtermStep+subtermStepTypeApplicationBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepTypeApplicationBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeApplicationBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the typeLambdaBody variant of hydra.paths.SubtermStep+subtermStepTypeLambdaBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepTypeLambdaBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeLambdaBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the wrapBody variant of hydra.paths.SubtermStep+subtermStepWrapBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepWrapBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrapBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.paths.SubtypeLink+subtypeLink :: Typed.TypedTerm Paths.SubtypeStep -> Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm Paths.SubtypeLink+subtypeLink step child =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm step)},+        Core.Field {+          Core.fieldName = (Core.Name "child"),+          Core.fieldTerm = (Typed.unTypedTerm child)}]}))++-- | DSL accessor for the child field of hydra.paths.SubtypeLink+subtypeLinkChild :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.TypeNode+subtypeLinkChild x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),+        Core.projectionFieldName = (Core.Name "child")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the step field of hydra.paths.SubtypeLink+subtypeLinkStep :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.SubtypeStep+subtypeLinkStep x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),+        Core.projectionFieldName = (Core.Name "step")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.SubtypeLink+subtypeLinkSubtypeLink :: Typed.TypedName Paths.SubtypeLink+subtypeLinkSubtypeLink = Typed.TypedName (Core.Name "hydra.paths.SubtypeLink")++-- | DSL updater for the child field of hydra.paths.SubtypeLink+subtypeLinkWithChild :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm Paths.SubtypeLink+subtypeLinkWithChild original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),+              Core.projectionFieldName = (Core.Name "step")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "child"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the step field of hydra.paths.SubtypeLink+subtypeLinkWithStep :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.SubtypeStep -> Typed.TypedTerm Paths.SubtypeLink+subtypeLinkWithStep original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "child"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),+              Core.projectionFieldName = (Core.Name "child")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.paths.SubtypePath wrapper+subtypePath :: Typed.TypedTerm [Paths.SubtypeStep] -> Typed.TypedTerm Paths.SubtypePath+subtypePath x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL 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 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotatedBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the applicationArgument variant of hydra.paths.SubtypeStep+subtypeStepApplicationArgument :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepApplicationArgument =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "applicationArgument"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the applicationFunction variant of hydra.paths.SubtypeStep+subtypeStepApplicationFunction :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepApplicationFunction =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "applicationFunction"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the effectValue variant of hydra.paths.SubtypeStep+subtypeStepEffectValue :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepEffectValue =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "effectValue"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the eitherLeft variant of hydra.paths.SubtypeStep+subtypeStepEitherLeft :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepEitherLeft =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "eitherLeft"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the eitherRight variant of hydra.paths.SubtypeStep+subtypeStepEitherRight :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepEitherRight =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "eitherRight"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the forallBody variant of hydra.paths.SubtypeStep+subtypeStepForallBody :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepForallBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "forallBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the functionCodomain variant of hydra.paths.SubtypeStep+subtypeStepFunctionCodomain :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepFunctionCodomain =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "functionCodomain"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the functionDomain variant of hydra.paths.SubtypeStep+subtypeStepFunctionDomain :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepFunctionDomain =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "functionDomain"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the listElement variant of hydra.paths.SubtypeStep+subtypeStepListElement :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepListElement =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "listElement"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the mapKeys variant of hydra.paths.SubtypeStep+subtypeStepMapKeys :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepMapKeys =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapKeys"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the mapValues variant of hydra.paths.SubtypeStep+subtypeStepMapValues :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepMapValues =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapValues"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the optionalElement variant of hydra.paths.SubtypeStep+subtypeStepOptionalElement :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepOptionalElement =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "optionalElement"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the pairFirst variant of hydra.paths.SubtypeStep+subtypeStepPairFirst :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepPairFirst =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pairFirst"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the pairSecond variant of hydra.paths.SubtypeStep+subtypeStepPairSecond :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepPairSecond =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pairSecond"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the recordField variant of hydra.paths.SubtypeStep+subtypeStepRecordField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeStep+subtypeStepRecordField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "recordField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the setElement variant of hydra.paths.SubtypeStep+subtypeStepSetElement :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepSetElement =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "setElement"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL 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+subtypeStepUnionField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unionField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the wrapBody variant of hydra.paths.SubtypeStep+subtypeStepWrapBody :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepWrapBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrapBody"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the casesTypeName variant of hydra.paths.TermAttributeLink+termAttributeLinkCasesTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkCasesTypeName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "casesTypeName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the injectTypeName variant of hydra.paths.TermAttributeLink+termAttributeLinkInjectTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkInjectTypeName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "injectTypeName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the lambdaDomainGiven variant of hydra.paths.TermAttributeLink+termAttributeLinkLambdaDomainGiven :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkLambdaDomainGiven x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lambdaDomainGiven"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the lambdaParameter variant of hydra.paths.TermAttributeLink+termAttributeLinkLambdaParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkLambdaParameter x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lambdaParameter"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the letBindingTypeSchemeGiven variant of hydra.paths.TermAttributeLink+termAttributeLinkLetBindingTypeSchemeGiven :: Typed.TypedTerm (Core.Name, Core.TypeScheme) -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkLetBindingTypeSchemeGiven x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "letBindingTypeSchemeGiven"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the literal variant of hydra.paths.TermAttributeLink+termAttributeLinkLiteral :: Typed.TypedTerm Core.Literal -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the projectFieldName variant of hydra.paths.TermAttributeLink+termAttributeLinkProjectFieldName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkProjectFieldName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "projectFieldName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the projectTypeName variant of hydra.paths.TermAttributeLink+termAttributeLinkProjectTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkProjectTypeName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "projectTypeName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the recordTypeName variant of hydra.paths.TermAttributeLink+termAttributeLinkRecordTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkRecordTypeName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "recordTypeName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.paths.TermAttributeLink+termAttributeLinkTermAttributeLink :: Typed.TypedName Paths.TermAttributeLink+termAttributeLinkTermAttributeLink = Typed.TypedName (Core.Name "hydra.paths.TermAttributeLink")++-- | DSL injection for the typeApplicationType variant of hydra.paths.TermAttributeLink+termAttributeLinkTypeApplicationType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkTypeApplicationType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeApplicationType"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the typeLambdaParameter variant of hydra.paths.TermAttributeLink+termAttributeLinkTypeLambdaParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkTypeLambdaParameter x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeLambdaParameter"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the unwrapTypeName variant of hydra.paths.TermAttributeLink+termAttributeLinkUnwrapTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkUnwrapTypeName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unwrapTypeName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the wrapTypeName variant of hydra.paths.TermAttributeLink+termAttributeLinkWrapTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink+termAttributeLinkWrapTypeName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrapTypeName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.paths.TermGraph+termGraph :: Typed.TypedTerm (M.Map Core.Name Paths.TermNode) -> Typed.TypedTerm Paths.TermGraph+termGraph roots =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "roots"),+          Core.fieldTerm = (Typed.unTypedTerm roots)}]}))++-- | DSL accessor for the roots field of hydra.paths.TermGraph+termGraphRoots :: Typed.TypedTerm Paths.TermGraph -> Typed.TypedTerm (M.Map Core.Name Paths.TermNode)+termGraphRoots x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TermGraph"),+        Core.projectionFieldName = (Core.Name "roots")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TermGraph+termGraphTermGraph :: Typed.TypedName Paths.TermGraph+termGraphTermGraph = Typed.TypedName (Core.Name "hydra.paths.TermGraph")++-- | DSL updater for the roots field of hydra.paths.TermGraph+termGraphWithRoots :: Typed.TypedTerm Paths.TermGraph -> Typed.TypedTerm (M.Map Core.Name Paths.TermNode) -> Typed.TypedTerm Paths.TermGraph+termGraphWithRoots original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "roots"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the attribute variant of hydra.paths.TermLink+termLinkAttribute :: Typed.TypedTerm Paths.TermAttributeLink -> Typed.TypedTerm Paths.TermLink+termLinkAttribute x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "attribute"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the reference variant of hydra.paths.TermLink+termLinkReference :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.TermLink+termLinkReference x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "reference"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the subterm variant of hydra.paths.TermLink+termLinkSubterm :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.TermLink+termLinkSubterm x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "subterm"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.paths.TermLink+termLinkTermLink :: Typed.TypedName Paths.TermLink+termLinkTermLink = Typed.TypedName (Core.Name "hydra.paths.TermLink")++-- | DSL constructor for hydra.paths.TermNode+termNode :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Type -> Typed.TypedTerm [Paths.TermLink] -> Typed.TypedTerm Paths.TermNode+termNode term type_ links =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm term)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = (Typed.unTypedTerm links)}]}))++-- | DSL constructor for hydra.paths.TermNodeId+termNodeId :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.TermNodeId+termNodeId root path =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNodeId"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "root"),+          Core.fieldTerm = (Typed.unTypedTerm root)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)}]}))++-- | DSL accessor for the path field of hydra.paths.TermNodeId+termNodeIdPath :: Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Paths.SubtermPath+termNodeIdPath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TermNodeId"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the root field of hydra.paths.TermNodeId+termNodeIdRoot :: Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Core.Name+termNodeIdRoot x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TermNodeId"),+        Core.projectionFieldName = (Core.Name "root")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TermNodeId+termNodeIdTermNodeId :: Typed.TypedName Paths.TermNodeId+termNodeIdTermNodeId = Typed.TypedName (Core.Name "hydra.paths.TermNodeId")++-- | DSL updater for the path field of hydra.paths.TermNodeId+termNodeIdWithPath :: Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.TermNodeId+termNodeIdWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNodeId"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "root"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermNodeId"),+              Core.projectionFieldName = (Core.Name "root")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the root field of hydra.paths.TermNodeId+termNodeIdWithRoot :: Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermNodeId+termNodeIdWithRoot original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNodeId"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "root"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermNodeId"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL accessor for the links field of hydra.paths.TermNode+termNodeLinks :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm [Paths.TermLink]+termNodeLinks x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+        Core.projectionFieldName = (Core.Name "links")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the term field of hydra.paths.TermNode+termNodeTerm :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Core.Term+termNodeTerm x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+        Core.projectionFieldName = (Core.Name "term")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TermNode+termNodeTermNode :: Typed.TypedName Paths.TermNode+termNodeTermNode = Typed.TypedName (Core.Name "hydra.paths.TermNode")++-- | DSL accessor for the type field of hydra.paths.TermNode+termNodeType :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Core.Type+termNodeType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the links field of hydra.paths.TermNode+termNodeWithLinks :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm [Paths.TermLink] -> Typed.TypedTerm Paths.TermNode+termNodeWithLinks original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the term field of hydra.paths.TermNode+termNodeWithTerm :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Paths.TermNode+termNodeWithTerm original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+              Core.projectionFieldName = (Core.Name "links")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the type field of hydra.paths.TermNode+termNodeWithType :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TermNode+termNodeWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),+              Core.projectionFieldName = (Core.Name "links")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the lambda variant of hydra.paths.TermReference+termReferenceLambda :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Paths.TermReference+termReferenceLambda x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lambda"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the let variant of hydra.paths.TermReference+termReferenceLet :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Paths.TermReference+termReferenceLet x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "let"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.paths.TermReferenceLink+termReferenceLink :: Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Paths.TermReference -> Typed.TypedTerm Paths.TermReferenceLink+termReferenceLink step target =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermReferenceLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm step)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm target)}]}))++-- | DSL accessor for the step field of hydra.paths.TermReferenceLink+termReferenceLinkStep :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.SubtermStep+termReferenceLinkStep x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TermReferenceLink"),+        Core.projectionFieldName = (Core.Name "step")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the target field of hydra.paths.TermReferenceLink+termReferenceLinkTarget :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.TermReference+termReferenceLinkTarget x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TermReferenceLink"),+        Core.projectionFieldName = (Core.Name "target")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TermReferenceLink+termReferenceLinkTermReferenceLink :: Typed.TypedName Paths.TermReferenceLink+termReferenceLinkTermReferenceLink = Typed.TypedName (Core.Name "hydra.paths.TermReferenceLink")++-- | DSL updater for the step field of hydra.paths.TermReferenceLink+termReferenceLinkWithStep :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Paths.TermReferenceLink+termReferenceLinkWithStep original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermReferenceLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermReferenceLink"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the target field of hydra.paths.TermReferenceLink+termReferenceLinkWithTarget :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.TermReference -> Typed.TypedTerm Paths.TermReferenceLink+termReferenceLinkWithTarget original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermReferenceLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TermReferenceLink"),+              Core.projectionFieldName = (Core.Name "step")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the primitive variant of hydra.paths.TermReference+termReferencePrimitive :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Paths.TermReference+termReferencePrimitive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primitive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.paths.TermReference+termReferenceTermReference :: Typed.TypedName Paths.TermReference+termReferenceTermReference = Typed.TypedName (Core.Name "hydra.paths.TermReference")++-- | DSL injection for the annotatedAnnotation variant of hydra.paths.TypeAttributeLink+typeAttributeLinkAnnotatedAnnotation :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Paths.TypeAttributeLink+typeAttributeLinkAnnotatedAnnotation x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotatedAnnotation"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the forallParameter variant of hydra.paths.TypeAttributeLink+typeAttributeLinkForallParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeAttributeLink+typeAttributeLinkForallParameter x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "forallParameter"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the literal variant of hydra.paths.TypeAttributeLink+typeAttributeLinkLiteral :: Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm Paths.TypeAttributeLink+typeAttributeLinkLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.paths.TypeAttributeLink+typeAttributeLinkTypeAttributeLink :: Typed.TypedName Paths.TypeAttributeLink+typeAttributeLinkTypeAttributeLink = Typed.TypedName (Core.Name "hydra.paths.TypeAttributeLink")++-- | DSL constructor for hydra.paths.TypeGraph+typeGraph :: Typed.TypedTerm (M.Map Core.Name Paths.TypeNode) -> Typed.TypedTerm Paths.TypeGraph+typeGraph roots =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "roots"),+          Core.fieldTerm = (Typed.unTypedTerm roots)}]}))++-- | DSL accessor for the roots field of hydra.paths.TypeGraph+typeGraphRoots :: Typed.TypedTerm Paths.TypeGraph -> Typed.TypedTerm (M.Map Core.Name Paths.TypeNode)+typeGraphRoots x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeGraph"),+        Core.projectionFieldName = (Core.Name "roots")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TypeGraph+typeGraphTypeGraph :: Typed.TypedName Paths.TypeGraph+typeGraphTypeGraph = Typed.TypedName (Core.Name "hydra.paths.TypeGraph")++-- | DSL updater for the roots field of hydra.paths.TypeGraph+typeGraphWithRoots :: Typed.TypedTerm Paths.TypeGraph -> Typed.TypedTerm (M.Map Core.Name Paths.TypeNode) -> Typed.TypedTerm Paths.TypeGraph+typeGraphWithRoots original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "roots"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the attribute variant of hydra.paths.TypeLink+typeLinkAttribute :: Typed.TypedTerm Paths.TypeAttributeLink -> Typed.TypedTerm Paths.TypeLink+typeLinkAttribute x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "attribute"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the reference variant of hydra.paths.TypeLink+typeLinkReference :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.TypeLink+typeLinkReference x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "reference"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the subtype variant of hydra.paths.TypeLink+typeLinkSubtype :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.TypeLink+typeLinkSubtype x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "subtype"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.paths.TypeLink+typeLinkTypeLink :: Typed.TypedName Paths.TypeLink+typeLinkTypeLink = Typed.TypedName (Core.Name "hydra.paths.TypeLink")++-- | DSL constructor for hydra.paths.TypeNode+typeNode :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Paths.TypeLink] -> Typed.TypedTerm Paths.TypeNode+typeNode type_ links =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = (Typed.unTypedTerm links)}]}))++-- | DSL constructor for hydra.paths.TypeNodeId+typeNodeId :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.TypeNodeId+typeNodeId root path =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeNodeId"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "root"),+          Core.fieldTerm = (Typed.unTypedTerm root)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)}]}))++-- | DSL accessor for the path field of hydra.paths.TypeNodeId+typeNodeIdPath :: Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Paths.SubtypePath+typeNodeIdPath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeNodeId"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the root field of hydra.paths.TypeNodeId+typeNodeIdRoot :: Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Core.Name+typeNodeIdRoot x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeNodeId"),+        Core.projectionFieldName = (Core.Name "root")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TypeNodeId+typeNodeIdTypeNodeId :: Typed.TypedName Paths.TypeNodeId+typeNodeIdTypeNodeId = Typed.TypedName (Core.Name "hydra.paths.TypeNodeId")++-- | DSL updater for the path field of hydra.paths.TypeNodeId+typeNodeIdWithPath :: Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.TypeNodeId+typeNodeIdWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeNodeId"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "root"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TypeNodeId"),+              Core.projectionFieldName = (Core.Name "root")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the root field of hydra.paths.TypeNodeId+typeNodeIdWithRoot :: Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeNodeId+typeNodeIdWithRoot original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeNodeId"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "root"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TypeNodeId"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL accessor for the links field of hydra.paths.TypeNode+typeNodeLinks :: Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm [Paths.TypeLink]+typeNodeLinks x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeNode"),+        Core.projectionFieldName = (Core.Name "links")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the type field of hydra.paths.TypeNode+typeNodeType :: Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm Core.Type+typeNodeType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeNode"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TypeNode+typeNodeTypeNode :: Typed.TypedName Paths.TypeNode+typeNodeTypeNode = Typed.TypedName (Core.Name "hydra.paths.TypeNode")++-- | DSL updater for the links field of hydra.paths.TypeNode+typeNodeWithLinks :: Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm [Paths.TypeLink] -> Typed.TypedTerm Paths.TypeNode+typeNodeWithLinks original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TypeNode"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the type field of hydra.paths.TypeNode+typeNodeWithType :: Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TypeNode+typeNodeWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TypeNode"),+              Core.projectionFieldName = (Core.Name "links")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.paths.TypeReferenceLink+typeReferenceLink :: Typed.TypedTerm Paths.SubtypeStep -> Typed.TypedTerm Paths.TypeReference -> Typed.TypedTerm Paths.TypeReferenceLink+typeReferenceLink step target =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm step)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm target)}]}))++-- | DSL accessor for the step field of hydra.paths.TypeReferenceLink+typeReferenceLinkStep :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.SubtypeStep+typeReferenceLinkStep x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),+        Core.projectionFieldName = (Core.Name "step")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the target field of hydra.paths.TypeReferenceLink+typeReferenceLinkTarget :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.TypeReference+typeReferenceLinkTarget x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),+        Core.projectionFieldName = (Core.Name "target")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TypeReferenceLink+typeReferenceLinkTypeReferenceLink :: Typed.TypedName Paths.TypeReferenceLink+typeReferenceLinkTypeReferenceLink = Typed.TypedName (Core.Name "hydra.paths.TypeReferenceLink")++-- | DSL updater for the step field of hydra.paths.TypeReferenceLink+typeReferenceLinkWithStep :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.SubtypeStep -> Typed.TypedTerm Paths.TypeReferenceLink+typeReferenceLinkWithStep original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the target field of hydra.paths.TypeReferenceLink+typeReferenceLinkWithTarget :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.TypeReference -> Typed.TypedTerm Paths.TypeReferenceLink+typeReferenceLinkWithTarget original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),+              Core.projectionFieldName = (Core.Name "step")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the nominal variant of hydra.paths.TypeReference+typeReferenceNominal :: Typed.TypedTerm Paths.NominalTypeReference -> Typed.TypedTerm Paths.TypeReference+typeReferenceNominal x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TypeReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nominal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL name token for hydra.paths.TypeReference+typeReferenceTypeReference :: Typed.TypedName Paths.TypeReference+typeReferenceTypeReference = Typed.TypedName (Core.Name "hydra.paths.TypeReference")++-- | DSL injection for the variable variant of hydra.paths.TypeReference+typeReferenceVariable :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Paths.TypeReference+typeReferenceVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.TypeReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "variable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.paths.TypeVariableReference+typeVariableReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Paths.TypeVariableReference+typeVariableReference variable boundByNode =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Typed.unTypedTerm variable)},+        Core.Field {+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (Typed.unTypedTerm boundByNode)}]}))++-- | DSL accessor for the boundByNode field of hydra.paths.TypeVariableReference+typeVariableReferenceBoundByNode :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Paths.TypeNodeId+typeVariableReferenceBoundByNode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeVariableReference"),+        Core.projectionFieldName = (Core.Name "boundByNode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.paths.TypeVariableReference+typeVariableReferenceTypeVariableReference :: Typed.TypedName Paths.TypeVariableReference+typeVariableReferenceTypeVariableReference = Typed.TypedName (Core.Name "hydra.paths.TypeVariableReference")++-- | DSL accessor for the variable field of hydra.paths.TypeVariableReference+typeVariableReferenceVariable :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Core.Name+typeVariableReferenceVariable x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.TypeVariableReference"),+        Core.projectionFieldName = (Core.Name "variable")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the boundByNode field of hydra.paths.TypeVariableReference+typeVariableReferenceWithBoundByNode :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Paths.TypeVariableReference+typeVariableReferenceWithBoundByNode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TypeVariableReference"),+              Core.projectionFieldName = (Core.Name "variable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the variable field of hydra.paths.TypeVariableReference+typeVariableReferenceWithVariable :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeVariableReference+typeVariableReferenceWithVariable original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.TypeVariableReference"),+              Core.projectionFieldName = (Core.Name "boundByNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL accessor for the body of hydra.paths.SubtermPath unSubtermPath :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm [Paths.SubtermStep]

@@ -117,8 +117,8 @@         Core.fieldTerm = (Typed.unTypedTerm x)}}))  -- | DSL constructor for hydra.testing.TestCaseWithMetadata-testCaseWithMetadata :: Typed.TypedTerm String -> Typed.TypedTerm Testing.TestCase -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [Testing.Tag] -> Typed.TypedTerm Testing.TestCaseWithMetadata-testCaseWithMetadata name case_ description tags =+testCaseWithMetadata :: Typed.TypedTerm String -> Typed.TypedTerm Testing.TestCase -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [Testing.Tag] -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm Testing.TestCaseWithMetadata+testCaseWithMetadata name case_ description tags provisions =     Typed.TypedTerm (Core.TermRecord (Core.Record {       Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),       Core.recordFields = [@@ -133,7 +133,10 @@           Core.fieldTerm = (Typed.unTypedTerm description)},         Core.Field {           Core.fieldName = (Core.Name "tags"),-          Core.fieldTerm = (Typed.unTypedTerm tags)}]}))+          Core.fieldTerm = (Typed.unTypedTerm tags)},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Typed.unTypedTerm provisions)}]}))  -- | DSL accessor for the case field of hydra.testing.TestCaseWithMetadata testCaseWithMetadataCase :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm Testing.TestCase@@ -162,6 +165,15 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL accessor for the provisions field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataProvisions :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm [Core.Name]+testCaseWithMetadataProvisions x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+        Core.projectionFieldName = (Core.Name "provisions")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+ -- | DSL accessor for the tags field of hydra.testing.TestCaseWithMetadata testCaseWithMetadataTags :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm [Testing.Tag] testCaseWithMetadataTags x =@@ -204,6 +216,13 @@             Core.applicationFunction = (Core.TermProject (Core.Projection {               Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),               Core.projectionFieldName = (Core.Name "tags")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "provisions")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL updater for the description field of hydra.testing.TestCaseWithMetadata@@ -235,6 +254,13 @@             Core.applicationFunction = (Core.TermProject (Core.Projection {               Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),               Core.projectionFieldName = (Core.Name "tags")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "provisions")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL updater for the name field of hydra.testing.TestCaseWithMetadata@@ -266,8 +292,53 @@             Core.applicationFunction = (Core.TermProject (Core.Projection {               Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),               Core.projectionFieldName = (Core.Name "tags")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "provisions")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL updater for the provisions field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataWithProvisions :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm Testing.TestCaseWithMetadata+testCaseWithMetadataWithProvisions original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "case"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "case")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "tags"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "tags")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+ -- | DSL updater for the tags field of hydra.testing.TestCaseWithMetadata testCaseWithMetadataWithTags :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm [Testing.Tag] -> Typed.TypedTerm Testing.TestCaseWithMetadata testCaseWithMetadataWithTags original newVal =@@ -297,7 +368,14 @@             Core.applicationArgument = (Typed.unTypedTerm original)}))},         Core.Field {           Core.fieldName = (Core.Name "tags"),-          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "provisions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL constructor for hydra.testing.TestGroup testGroup :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [Testing.TestGroup] -> Typed.TypedTerm [Testing.TestCaseWithMetadata] -> Typed.TypedTerm Testing.TestGroup

@@ -50,6 +50,15 @@         Core.fieldName = (Core.Name "pascal"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL injection for the upperDashed variant of hydra.util.CaseConvention+caseConventionUpperDashed :: Typed.TypedTerm Util.CaseConvention+caseConventionUpperDashed =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "upperDashed"),+        Core.fieldTerm = Core.TermUnit}}))+ -- | DSL injection for the upperSnake variant of hydra.util.CaseConvention caseConventionUpperSnake :: Typed.TypedTerm Util.CaseConvention caseConventionUpperSnake =

@@ -119,7 +119,8 @@             (Packaging.unModuleName (Packaging.moduleName mod))])),           Packaging.entityMetadataComments = [],           Packaging.entityMetadataSeeAlso = [],-          Packaging.entityMetadataLifecycle = Nothing})),+          Packaging.entityMetadataLifecycle = Nothing,+          Packaging.entityMetadataProvisions = []})),         Packaging.moduleDependencies = (Lists.map (\ns -> Packaging.ModuleDependency {           Packaging.moduleDependencyModule = ns,           Packaging.moduleDependencyPackage = Nothing}) (Lists.distinct (Lists.concat2 [

@@ -187,6 +187,16 @@         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "invalidPackageName"),           Core.fieldTerm = (invalidPackageNameError v0)}})+      ErrorPackaging.InvalidPackageErrorModuleInMultiplePackages v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "moduleInMultiplePackages"),+          Core.fieldTerm = (moduleInMultiplePackagesError v0)}})+      ErrorPackaging.InvalidPackageErrorNestedModuleName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "nestedModuleName"),+          Core.fieldTerm = (nestedModuleNameError v0)}})       ErrorPackaging.InvalidPackageErrorUndeclaredDependency v0 -> Core.TermInject (Core.Injection {         Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),         Core.injectionField = Core.Field {@@ -215,6 +225,35 @@         Core.Field {           Core.fieldName = (Core.Name "name"),           Core.fieldTerm = (EncodeCore.name (ErrorPackaging.missingDocumentationErrorName x))}]})++-- | Encoder for hydra.error.packaging.ModuleInMultiplePackagesError+moduleInMultiplePackagesError :: ErrorPackaging.ModuleInMultiplePackagesError -> Core.Term+moduleInMultiplePackagesError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.moduleInMultiplePackagesErrorModuleName x))},+        Core.Field {+          Core.fieldName = (Core.Name "firstPackage"),+          Core.fieldTerm = (EncodePackaging.packageName (ErrorPackaging.moduleInMultiplePackagesErrorFirstPackage x))},+        Core.Field {+          Core.fieldName = (Core.Name "secondPackage"),+          Core.fieldTerm = (EncodePackaging.packageName (ErrorPackaging.moduleInMultiplePackagesErrorSecondPackage x))}]})++-- | Encoder for hydra.error.packaging.NestedModuleNameError+nestedModuleNameError :: ErrorPackaging.NestedModuleNameError -> Core.Term+nestedModuleNameError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.NestedModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "outer"),+          Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.nestedModuleNameErrorOuter x))},+        Core.Field {+          Core.fieldName = (Core.Name "inner"),+          Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.nestedModuleNameErrorInner x))}]})  -- | Encoder for hydra.error.packaging.UndeclaredDependencyError undeclaredDependencyError :: ErrorPackaging.UndeclaredDependencyError -> Core.Term

@@ -96,7 +96,10 @@           Core.fieldTerm = ((\xs -> Core.TermList (Lists.map entityReference xs)) (Packaging.entityMetadataSeeAlso x))},         Core.Field {           Core.fieldName = (Core.Name "lifecycle"),-          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map lifecycleInfo opt)) (Packaging.entityMetadataLifecycle x))}]})+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map lifecycleInfo opt)) (Packaging.entityMetadataLifecycle x))},+        Core.Field {+          Core.fieldName = (Core.Name "provisions"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map provision xs)) (Packaging.entityMetadataProvisions x))}]})  -- | Encoder for hydra.packaging.EntityReference entityReference :: Packaging.EntityReference -> Core.Term@@ -246,6 +249,37 @@         Core.Field {           Core.fieldName = (Core.Name "defaultImplementation"),           Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map EncodeCore.term opt)) (Packaging.primitiveDefinitionDefaultImplementation x))}]})++-- | Encoder for hydra.packaging.Provision+provision :: Packaging.Provision -> Core.Term+provision x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Provision"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Packaging.provisionName x))},+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (provisionKind (Packaging.provisionKind x))},+        Core.Field {+          Core.fieldName = (Core.Name "statement"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Packaging.provisionStatement x))}]})++-- | Encoder for hydra.packaging.ProvisionKind+provisionKind :: Packaging.ProvisionKind -> Core.Term+provisionKind x =+    case x of+      Packaging.ProvisionKindRequirement -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.ProvisionKind"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "requirement"),+          Core.fieldTerm = Core.TermUnit}})+      Packaging.ProvisionKindRecommendation -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.ProvisionKind"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "recommendation"),+          Core.fieldTerm = Core.TermUnit}})  -- | Encoder for hydra.packaging.TermDefinition termDefinition :: Packaging.TermDefinition -> Core.Term

@@ -7,83 +7,80 @@ import qualified Hydra.Core as Core import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Paths as Paths import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void --- | Encoder for hydra.paths.SubtermAttribute-subtermAttribute :: Paths.SubtermAttribute -> Core.Term-subtermAttribute x =+-- | Encoder for hydra.paths.LambdaVariableReference+lambdaVariableReference :: Paths.LambdaVariableReference -> Core.Term+lambdaVariableReference x =     Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermAttribute"),+      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),       Core.recordFields = [         Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (subtermPath (Paths.subtermAttributePath x))},+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (EncodeCore.name (Paths.lambdaVariableReferenceVariable x))},         Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (termAttribute (Paths.subtermAttributeTarget x))}]})+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (termNodeId (Paths.lambdaVariableReferenceBoundByNode x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Paths.lambdaVariableReferenceType x))}]}) --- | Encoder for hydra.paths.SubtermEdge-subtermEdge :: Paths.SubtermEdge -> Core.Term-subtermEdge x =+-- | Encoder for hydra.paths.LetVariableReference+letVariableReference :: Paths.LetVariableReference -> Core.Term+letVariableReference x =     Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),+      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),       Core.recordFields = [         Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (subtermPath (Paths.subtermEdgePath x))},+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (EncodeCore.name (Paths.letVariableReferenceVariable x))},         Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (EncodeCore.name (Paths.subtermEdgeTarget x))}]})+          Core.fieldName = (Core.Name "bindingNode"),+          Core.fieldTerm = (termNodeId (Paths.letVariableReferenceBindingNode x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Paths.letVariableReferenceType x))}]}) --- | Encoder for hydra.paths.SubtermGraph-subtermGraph :: Paths.SubtermGraph -> Core.Term-subtermGraph x =+-- | Encoder for hydra.paths.NominalTypeReference+nominalTypeReference :: Paths.NominalTypeReference -> Core.Term+nominalTypeReference x =     Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"),+      Core.recordTypeName = (Core.Name "hydra.paths.NominalTypeReference"),       Core.recordFields = [         Core.Field {-          Core.fieldName = (Core.Name "nodes"),-          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtermNode xs)) (Paths.subtermGraphNodes x))}]})---- | Encoder for hydra.paths.SubtermLink-subtermLink :: Paths.SubtermLink -> Core.Term-subtermLink x =-    case x of-      Paths.SubtermLinkEdge v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermLink"),-        Core.injectionField = Core.Field {-          Core.fieldName = (Core.Name "edge"),-          Core.fieldTerm = (subtermEdge v0)}})-      Paths.SubtermLinkProperty v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermLink"),-        Core.injectionField = Core.Field {-          Core.fieldName = (Core.Name "property"),-          Core.fieldTerm = (subtermProperty v0)}})-      Paths.SubtermLinkAttribute v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermLink"),-        Core.injectionField = Core.Field {-          Core.fieldName = (Core.Name "attribute"),-          Core.fieldTerm = (subtermAttribute v0)}})+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Paths.nominalTypeReferenceName x))}]}) --- | Encoder for hydra.paths.SubtermNode-subtermNode :: Paths.SubtermNode -> Core.Term-subtermNode x =+-- | Encoder for hydra.paths.PrimitiveReference+primitiveReference :: Paths.PrimitiveReference -> Core.Term+primitiveReference x =     Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),+      Core.recordTypeName = (Core.Name "hydra.paths.PrimitiveReference"),       Core.recordFields = [         Core.Field {           Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (EncodeCore.name (Paths.subtermNodeName x))},+          Core.fieldTerm = (EncodeCore.name (Paths.primitiveReferenceName x))},         Core.Field {           Core.fieldName = (Core.Name "type"),-          Core.fieldTerm = (EncodeCore.typeScheme (Paths.subtermNodeType x))},+          Core.fieldTerm = (EncodeCore.type_ (Paths.primitiveReferenceType x))}]})++-- | Encoder for hydra.paths.SubtermLink+subtermLink :: Paths.SubtermLink -> Core.Term+subtermLink x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermLink"),+      Core.recordFields = [         Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtermLink xs)) (Paths.subtermNodeLinks x))}]})+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (subtermStep (Paths.subtermLinkStep x))},+        Core.Field {+          Core.fieldName = (Core.Name "child"),+          Core.fieldTerm = (termNode (Paths.subtermLinkChild x))}]})  -- | Encoder for hydra.paths.SubtermPath subtermPath :: Paths.SubtermPath -> Core.Term@@ -92,19 +89,6 @@       Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),       Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map subtermStep xs)) (Paths.unSubtermPath x))}) --- | Encoder for hydra.paths.SubtermProperty-subtermProperty :: Paths.SubtermProperty -> Core.Term-subtermProperty x =-    Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtermProperty"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (subtermPath (Paths.subtermPropertyPath x))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (EncodeCore.term (Paths.subtermPropertyTarget x))}]})- -- | Encoder for hydra.paths.SubtermStep subtermStep :: Paths.SubtermStep -> Core.Term subtermStep x =@@ -174,15 +158,10 @@         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "listElement"),           Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})-      Paths.SubtermStepMapKey v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),-        Core.injectionField = Core.Field {-          Core.fieldName = (Core.Name "mapKey"),-          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})-      Paths.SubtermStepMapValue v0 -> Core.TermInject (Core.Injection {+      Paths.SubtermStepMapEntry v0 -> Core.TermInject (Core.Injection {         Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),         Core.injectionField = Core.Field {-          Core.fieldName = (Core.Name "mapValue"),+          Core.fieldName = (Core.Name "mapEntry"),           Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})       Paths.SubtermStepOptionalGiven -> Core.TermInject (Core.Injection {         Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),@@ -225,74 +204,18 @@           Core.fieldName = (Core.Name "wrapBody"),           Core.fieldTerm = Core.TermUnit}}) --- | Encoder for hydra.paths.SubtypeAttribute-subtypeAttribute :: Paths.SubtypeAttribute -> Core.Term-subtypeAttribute x =-    Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (subtypePath (Paths.subtypeAttributePath x))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (typeAttribute (Paths.subtypeAttributeTarget x))}]})---- | Encoder for hydra.paths.SubtypeEdge-subtypeEdge :: Paths.SubtypeEdge -> Core.Term-subtypeEdge x =-    Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (subtypePath (Paths.subtypeEdgePath x))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (EncodeCore.name (Paths.subtypeEdgeTarget x))}]})---- | Encoder for hydra.paths.SubtypeGraph-subtypeGraph :: Paths.SubtypeGraph -> Core.Term-subtypeGraph x =-    Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "nodes"),-          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtypeNode xs)) (Paths.subtypeGraphNodes x))}]})- -- | Encoder for hydra.paths.SubtypeLink subtypeLink :: Paths.SubtypeLink -> Core.Term subtypeLink x =-    case x of-      Paths.SubtypeLinkEdge v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),-        Core.injectionField = Core.Field {-          Core.fieldName = (Core.Name "edge"),-          Core.fieldTerm = (subtypeEdge v0)}})-      Paths.SubtypeLinkProperty v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),-        Core.injectionField = Core.Field {-          Core.fieldName = (Core.Name "property"),-          Core.fieldTerm = (subtypeProperty v0)}})-      Paths.SubtypeLinkAttribute v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),-        Core.injectionField = Core.Field {-          Core.fieldName = (Core.Name "attribute"),-          Core.fieldTerm = (subtypeAttribute v0)}})---- | Encoder for hydra.paths.SubtypeNode-subtypeNode :: Paths.SubtypeNode -> Core.Term-subtypeNode x =     Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeLink"),       Core.recordFields = [         Core.Field {-          Core.fieldName = (Core.Name "name"),-          Core.fieldTerm = (EncodeCore.name (Paths.subtypeNodeName x))},+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (subtypeStep (Paths.subtypeLinkStep x))},         Core.Field {-          Core.fieldName = (Core.Name "links"),-          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtypeLink xs)) (Paths.subtypeNodeLinks x))}]})+          Core.fieldName = (Core.Name "child"),+          Core.fieldTerm = (typeNode (Paths.subtypeLinkChild x))}]})  -- | Encoder for hydra.paths.SubtypePath subtypePath :: Paths.SubtypePath -> Core.Term@@ -301,19 +224,6 @@       Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),       Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map subtypeStep xs)) (Paths.unSubtypePath x))}) --- | Encoder for hydra.paths.SubtypeProperty-subtypeProperty :: Paths.SubtypeProperty -> Core.Term-subtypeProperty x =-    Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeProperty"),-      Core.recordFields = [-        Core.Field {-          Core.fieldName = (Core.Name "path"),-          Core.fieldTerm = (subtypePath (Paths.subtypePropertyPath x))},-        Core.Field {-          Core.fieldName = (Core.Name "target"),-          Core.fieldTerm = (EncodeCore.type_ (Paths.subtypePropertyTarget x))}]})- -- | Encoder for hydra.paths.SubtypeStep subtypeStep :: Paths.SubtypeStep -> Core.Term subtypeStep x =@@ -414,77 +324,281 @@           Core.fieldName = (Core.Name "wrapBody"),           Core.fieldTerm = Core.TermUnit}}) --- | Encoder for hydra.paths.TermAttribute-termAttribute :: Paths.TermAttribute -> Core.Term-termAttribute x =+-- | Encoder for hydra.paths.TermAttributeLink+termAttributeLink :: Paths.TermAttributeLink -> Core.Term+termAttributeLink x =     case x of-      Paths.TermAttributeCasesTypeName v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkCasesTypeName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "casesTypeName"),           Core.fieldTerm = (EncodeCore.name v0)}})-      Paths.TermAttributeInjectTypeName v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkInjectTypeName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "injectTypeName"),           Core.fieldTerm = (EncodeCore.name v0)}})-      Paths.TermAttributeLambdaDomainGiven v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkLambdaDomainGiven v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "lambdaDomainGiven"),           Core.fieldTerm = (EncodeCore.type_ v0)}})-      Paths.TermAttributeLambdaParameter v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkLambdaParameter v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "lambdaParameter"),           Core.fieldTerm = (EncodeCore.name v0)}})-      Paths.TermAttributeLetBindingTypeSchemeGiven v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkLetBindingTypeSchemeGiven v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "letBindingTypeSchemeGiven"),           Core.fieldTerm = (Core.TermPair (Pairs.bimap EncodeCore.name EncodeCore.typeScheme v0))}})-      Paths.TermAttributeProjectFieldName v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkLiteral v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "literal"),+          Core.fieldTerm = (EncodeCore.literal v0)}})+      Paths.TermAttributeLinkProjectFieldName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+        Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "projectFieldName"),           Core.fieldTerm = (EncodeCore.name v0)}})-      Paths.TermAttributeProjectTypeName v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkProjectTypeName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "projectTypeName"),           Core.fieldTerm = (EncodeCore.name v0)}})-      Paths.TermAttributeRecordTypeName v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkRecordTypeName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "recordTypeName"),           Core.fieldTerm = (EncodeCore.name v0)}})-      Paths.TermAttributeTypeApplicationType v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkTypeApplicationType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "typeApplicationType"),           Core.fieldTerm = (EncodeCore.type_ v0)}})-      Paths.TermAttributeTypeLambdaParameter v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkTypeLambdaParameter v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "typeLambdaParameter"),           Core.fieldTerm = (EncodeCore.name v0)}})-      Paths.TermAttributeWrapTypeName v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),+      Paths.TermAttributeLinkUnwrapTypeName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),         Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unwrapTypeName"),+          Core.fieldTerm = (EncodeCore.name v0)}})+      Paths.TermAttributeLinkWrapTypeName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),+        Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "wrapTypeName"),           Core.fieldTerm = (EncodeCore.name v0)}}) --- | Encoder for hydra.paths.TypeAttribute-typeAttribute :: Paths.TypeAttribute -> Core.Term-typeAttribute x =+-- | Encoder for hydra.paths.TermGraph+termGraph :: Paths.TermGraph -> Core.Term+termGraph x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "roots"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name termNode m)) (Paths.termGraphRoots x))}]})++-- | Encoder for hydra.paths.TermLink+termLink :: Paths.TermLink -> Core.Term+termLink x =     case x of-      Paths.TypeAttributeAnnotatedAnnotation v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttribute"),+      Paths.TermLinkAttribute v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),         Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "attribute"),+          Core.fieldTerm = (termAttributeLink v0)}})+      Paths.TermLinkReference v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "reference"),+          Core.fieldTerm = (termReferenceLink v0)}})+      Paths.TermLinkSubterm v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "subterm"),+          Core.fieldTerm = (subtermLink v0)}})++-- | Encoder for hydra.paths.TermNode+termNode :: Paths.TermNode -> Core.Term+termNode x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (EncodeCore.term (Paths.termNodeTerm x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Paths.termNodeType x))},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map termLink xs)) (Paths.termNodeLinks x))}]})++-- | Encoder for hydra.paths.TermNodeId+termNodeId :: Paths.TermNodeId -> Core.Term+termNodeId x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermNodeId"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "root"),+          Core.fieldTerm = (EncodeCore.name (Paths.termNodeIdRoot x))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (subtermPath (Paths.termNodeIdPath x))}]})++-- | Encoder for hydra.paths.TermReference+termReference :: Paths.TermReference -> Core.Term+termReference x =+    case x of+      Paths.TermReferenceLambda v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "lambda"),+          Core.fieldTerm = (lambdaVariableReference v0)}})+      Paths.TermReferenceLet v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "let"),+          Core.fieldTerm = (letVariableReference v0)}})+      Paths.TermReferencePrimitive v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "primitive"),+          Core.fieldTerm = (primitiveReference v0)}})++-- | Encoder for hydra.paths.TermReferenceLink+termReferenceLink :: Paths.TermReferenceLink -> Core.Term+termReferenceLink x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TermReferenceLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (subtermStep (Paths.termReferenceLinkStep x))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (termReference (Paths.termReferenceLinkTarget x))}]})++-- | Encoder for hydra.paths.TypeAttributeLink+typeAttributeLink :: Paths.TypeAttributeLink -> Core.Term+typeAttributeLink x =+    case x of+      Paths.TypeAttributeLinkAnnotatedAnnotation v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),+        Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "annotatedAnnotation"),           Core.fieldTerm = (EncodeCore.term v0)}})-      Paths.TypeAttributeForallParameter v0 -> Core.TermInject (Core.Injection {-        Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttribute"),+      Paths.TypeAttributeLinkForallParameter v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "forallParameter"),           Core.fieldTerm = (EncodeCore.name v0)}})+      Paths.TypeAttributeLinkLiteral v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "literal"),+          Core.fieldTerm = (EncodeCore.literalType v0)}})++-- | Encoder for hydra.paths.TypeGraph+typeGraph :: Paths.TypeGraph -> Core.Term+typeGraph x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "roots"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name typeNode m)) (Paths.typeGraphRoots x))}]})++-- | Encoder for hydra.paths.TypeLink+typeLink :: Paths.TypeLink -> Core.Term+typeLink x =+    case x of+      Paths.TypeLinkAttribute v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "attribute"),+          Core.fieldTerm = (typeAttributeLink v0)}})+      Paths.TypeLinkReference v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "reference"),+          Core.fieldTerm = (typeReferenceLink v0)}})+      Paths.TypeLinkSubtype v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "subtype"),+          Core.fieldTerm = (subtypeLink v0)}})++-- | Encoder for hydra.paths.TypeNode+typeNode :: Paths.TypeNode -> Core.Term+typeNode x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Paths.typeNodeType x))},+        Core.Field {+          Core.fieldName = (Core.Name "links"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map typeLink xs)) (Paths.typeNodeLinks x))}]})++-- | Encoder for hydra.paths.TypeNodeId+typeNodeId :: Paths.TypeNodeId -> Core.Term+typeNodeId x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeNodeId"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "root"),+          Core.fieldTerm = (EncodeCore.name (Paths.typeNodeIdRoot x))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (subtypePath (Paths.typeNodeIdPath x))}]})++-- | Encoder for hydra.paths.TypeReference+typeReference :: Paths.TypeReference -> Core.Term+typeReference x =+    case x of+      Paths.TypeReferenceNominal v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TypeReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "nominal"),+          Core.fieldTerm = (nominalTypeReference v0)}})+      Paths.TypeReferenceVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.TypeReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (typeVariableReference v0)}})++-- | Encoder for hydra.paths.TypeReferenceLink+typeReferenceLink :: Paths.TypeReferenceLink -> Core.Term+typeReferenceLink x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (subtypeStep (Paths.typeReferenceLinkStep x))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (typeReference (Paths.typeReferenceLinkTarget x))}]})++-- | Encoder for hydra.paths.TypeVariableReference+typeVariableReference :: Paths.TypeVariableReference -> Core.Term+typeVariableReference x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.TypeVariableReference"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (EncodeCore.name (Paths.typeVariableReferenceVariable x))},+        Core.Field {+          Core.fieldName = (Core.Name "boundByNode"),+          Core.fieldTerm = (typeNodeId (Paths.typeVariableReferenceBoundByNode x))}]})

@@ -39,6 +39,11 @@         Core.injectionField = Core.Field {           Core.fieldName = (Core.Name "upperSnake"),           Core.fieldTerm = Core.TermUnit}})+      Util.CaseConventionUpperDashed -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "upperDashed"),+          Core.fieldTerm = Core.TermUnit}})  -- | Encoder for hydra.util.Comparison comparison :: Util.Comparison -> Core.Term

@@ -331,7 +331,8 @@           (Packaging.unModuleName (Packaging.moduleName mod))])),         Packaging.entityMetadataComments = [],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.moduleDependencies = (Lists.map (\ns -> Packaging.ModuleDependency {         Packaging.moduleDependencyModule = ns,         Packaging.moduleDependencyPackage = Nothing}) (Lists.distinct (Lists.concat2 (Lists.map encodeModuleName (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod))) [

@@ -183,6 +183,10 @@   InvalidPackageErrorInvalidModule InvalidModuleError |   -- | A package whose name does not match the package-name naming convention   InvalidPackageErrorInvalidPackageName InvalidPackageNameError |+  -- | A module namespace declared by more than one package+  InvalidPackageErrorModuleInMultiplePackages ModuleInMultiplePackagesError |+  -- | A module namespace that is a strict dotted-prefix of another module namespace in the same package+  InvalidPackageErrorNestedModuleName NestedModuleNameError |   -- | A module references a name owned by another module that is not among its declared dependencies   InvalidPackageErrorUndeclaredDependency UndeclaredDependencyError   deriving (Eq, Ord, Read, Show)@@ -197,6 +201,10 @@  _InvalidPackageError_invalidPackageName = Core.Name "invalidPackageName" +_InvalidPackageError_moduleInMultiplePackages = Core.Name "moduleInMultiplePackages"++_InvalidPackageError_nestedModuleName = Core.Name "nestedModuleName"+ _InvalidPackageError_undeclaredDependency = Core.Name "undeclaredDependency"  -- | A package whose name does not match the hyphen-separated lowercase naming convention. Package names must be hyphen-separated lowercase segments, each starting with a letter, e.g. hydra-kernel or hydra-python.@@ -224,6 +232,40 @@ _MissingDocumentationError_moduleName = Core.Name "moduleName"  _MissingDocumentationError_name = Core.Name "name"++-- | A module namespace declared by more than one package. Module-to-package routing requires each package's declared module set to partition the module universe; a namespace declared by two packages would otherwise be routed to one of them arbitrarily, with the other declaration silently ignored.+data ModuleInMultiplePackagesError =+  ModuleInMultiplePackagesError {+    -- | The module namespace declared by more than one package+    moduleInMultiplePackagesErrorModuleName :: Packaging.ModuleName,+    -- | The name of the first package declaring the module+    moduleInMultiplePackagesErrorFirstPackage :: Packaging.PackageName,+    -- | The name of the second package declaring the module+    moduleInMultiplePackagesErrorSecondPackage :: Packaging.PackageName}+  deriving (Eq, Ord, Read, Show)++_ModuleInMultiplePackagesError = Core.Name "hydra.error.packaging.ModuleInMultiplePackagesError"++_ModuleInMultiplePackagesError_moduleName = Core.Name "moduleName"++_ModuleInMultiplePackagesError_firstPackage = Core.Name "firstPackage"++_ModuleInMultiplePackagesError_secondPackage = Core.Name "secondPackage"++-- | A module namespace which is a strict dotted-prefix of another module namespace in the same package, e.g. hydra.codegen and hydra.codegen.docs. When two such namespaces coexist, a definition name that is prefix-valid for both modules cannot be unambiguously assigned to one.+data NestedModuleNameError =+  NestedModuleNameError {+    -- | The shorter namespace, a strict dotted-prefix of the inner namespace+    nestedModuleNameErrorOuter :: Packaging.ModuleName,+    -- | The longer namespace, which has the outer namespace as a strict dotted-prefix+    nestedModuleNameErrorInner :: Packaging.ModuleName}+  deriving (Eq, Ord, Read, Show)++_NestedModuleNameError = Core.Name "hydra.error.packaging.NestedModuleNameError"++_NestedModuleNameError_outer = Core.Name "outer"++_NestedModuleNameError_inner = Core.Name "inner"  -- | A module references a name owned by another module which is not among its declared moduleDependencies. Like a missing import: the reference may still resolve today via another module's transitive dependencies, but the declared dependency list no longer reflects what the module actually uses, and inference-time resolution is not guaranteed. data UndeclaredDependencyError =

@@ -67,16 +67,19 @@                           in (Lists.map Strings.fromList (Lists.foldl splitOnUppercase [                             []] (Lists.reverse (Strings.toList (decapitalize original)))))                     byUnderscores = Strings.splitOn "_" original+                    byDashes = Strings.splitOn "-" original                 in case from of                   Util.CaseConventionCamel -> byCaps                   Util.CaseConventionPascal -> byCaps                   Util.CaseConventionLowerSnake -> byUnderscores                   Util.CaseConventionUpperSnake -> byUnderscores+                  Util.CaseConventionUpperDashed -> byDashes       in case to of         Util.CaseConventionCamel -> decapitalize (Strings.concat (Lists.map (\arg_ -> capitalize (Strings.toLower arg_)) parts))         Util.CaseConventionPascal -> Strings.concat (Lists.map (\arg_ -> capitalize (Strings.toLower arg_)) parts)         Util.CaseConventionLowerSnake -> Strings.join "_" (Lists.map Strings.toLower parts)         Util.CaseConventionUpperSnake -> Strings.join "_" (Lists.map Strings.toUpper parts)+        Util.CaseConventionUpperDashed -> Strings.join "-" (Lists.map Strings.toUpper parts)  -- | Convert a string from camel case (possibly with underscores) to lower snake case. Splits on underscores first, then converts each part from camel case. convertCaseCamelOrUnderscoreToLowerSnake :: String -> String

@@ -2363,11 +2363,19 @@                 Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [                   (                     Core.TermVariable (Core.Name "description"),-                    (Core.TermLiteral (Core.LiteralString "Optional version-lifecycle milestones for the entity.")))]))}))}]),+                    (Core.TermLiteral (Core.LiteralString "Optional version-lifecycle milestones for the entity.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "provisions"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.packaging.Provision"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Named normative provisions (requirements and recommendations) concerning this entity. Empty when the entity states none.")))]))}))}]),           Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [             (               Core.TermVariable (Core.Name "description"),-              (Core.TermLiteral (Core.LiteralString "Documentation and lifecycle metadata attachable to a packaging entity (package, module, or definition). Bundling these fields in one type lets future metadata be added without changing the field shape of the entities that carry it.")))]))}))),+              (Core.TermLiteral (Core.LiteralString "Documentation, lifecycle, and normative metadata attachable to a packaging entity (package, module, or definition). Bundling these fields in one type lets future metadata be added without changing the field shape of the entities that carry it.")))]))}))),       (         Core.Name "hydra.packaging.EntityReference",         (Core.TypeAnnotated (Core.AnnotatedType {@@ -2633,6 +2641,62 @@               Core.TermVariable (Core.Name "description"),               (Core.TermLiteral (Core.LiteralString "A primitive definition: the universal, host-independent declarative metadata for a primitive, including name, signature, documentation and lifecycle metadata, totality and purity flags, and an optional default implementation expressed as a Hydra term.")))]))}))),       (+        Core.Name "hydra.packaging.Provision",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The fully-qualified name of the provision: the enclosing entity's name extended by one segment (e.g. hydra.lib.lists.concat.emptyLists). Composed at definition time by a helper that prefixes the entity's name, exactly as a definition's name is composed from its module's name -- so the author writes only the final segment, but the stored value is the full name.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "kind"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.ProvisionKind")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Whether this provision is a requirement or a recommendation.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "statement"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The normative statement itself, as markdown prose: the falsifiable claim.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A named normative statement concerning an entity: a single falsifiable condition a conforming implementation is measured against. Tests reference provisions by name.")))]))}))),+      (+        Core.Name "hydra.packaging.ProvisionKind",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "requirement"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A requirement: no deviation is permitted if conformance is to be claimed (MUST).")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "recommendation"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A recommendation: observed strictly by the Hydra kernel and codebase, but a downstream project may opt out (SHOULD).")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Whether a provision is a requirement (a MUST: no deviation permitted for conformance) or a recommendation (a SHOULD: observed by the Hydra kernel, but a downstream project may opt out).")))]))}))),+      (         Core.Name "hydra.packaging.TermDefinition",         (Core.TypeAnnotated (Core.AnnotatedType {           Core.annotatedTypeBody = (Core.TypeRecord [@@ -3085,6 +3149,9 @@               Core.fieldTypeType = Core.TypeUnit},             Core.FieldType {               Core.fieldTypeName = (Core.Name "upperSnake"),+              Core.fieldTypeType = Core.TypeUnit},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "upperDashed"),               Core.fieldTypeType = Core.TypeUnit}]),           Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [             (

@@ -197,16 +197,18 @@         Core.TypeLiteral v0 -> decodeLiteral v0 value         Core.TypeList v0 ->           let decodeElem = \v -> fromJson types compactMaps tname v0 v-              arrResult = expectArray value-          in (Eithers.either (\err -> Left err) (\arr ->-            let decoded = Eithers.mapList decodeElem arr-            in (Eithers.map (\ts -> Core.TermList ts) decoded)) arrResult)+          in case value of+            Model.ValueNull -> Right (Core.TermList [])+            _ -> Eithers.either (\err -> Left err) (\arr ->+              let decoded = Eithers.mapList decodeElem arr+              in (Eithers.map (\ts -> Core.TermList ts) decoded)) (expectArray value)         Core.TypeSet v0 ->           let decodeElem = \v -> fromJson types compactMaps tname v0 v-              arrResult = expectArray value-          in (Eithers.either (\err -> Left err) (\arr ->-            let decoded = Eithers.mapList decodeElem arr-            in (Eithers.map (\elems -> Core.TermSet (Sets.fromList elems)) decoded)) arrResult)+          in case value of+            Model.ValueNull -> Right (Core.TermSet Sets.empty)+            _ -> Eithers.either (\err -> Left err) (\arr ->+              let decoded = Eithers.mapList decodeElem arr+              in (Eithers.map (\elems -> Core.TermSet (Sets.fromList elems)) decoded)) (expectArray value)         Core.TypeOptional v0 ->           let innerStripped = Strip.deannotateType v0               isNestedMaybe =@@ -344,11 +346,11 @@           in (Eithers.either (\err -> Left err) (\obj ->             let leftJson = Maps.lookup "left" obj                 rightJson = Maps.lookup "right" obj-            in (Optionals.match leftJson (Optionals.match rightJson (Left "expected left or right in Either") (\rj ->+            in (Logic.ifElse (Logic.and (Optionals.isGiven leftJson) (Optionals.isGiven rightJson)) (Left "Either object must not carry both left and right keys") (Optionals.match leftJson (Optionals.match rightJson (Left "expected left or right in Either") (\rj ->               let decoded = fromJson types compactMaps tname rightType rj               in (Eithers.map (\v -> Core.TermEither (Right v)) decoded))) (\lj ->               let decoded = fromJson types compactMaps tname leftType lj-              in (Eithers.map (\v -> Core.TermEither (Left v)) decoded)))) objResult)+              in (Eithers.map (\v -> Core.TermEither (Left v)) decoded))))) objResult)         Core.TypeVariable v0 ->           let lookedUp = Maps.lookup v0 types           in (Optionals.match lookedUp (Left (Strings.concat [

@@ -107,7 +107,7 @@     token (Parsers.bind jsonIntegerPart (\intPart -> Parsers.bind jsonFractionPart (\fracPart -> Parsers.bind jsonExponentPart (\expPart ->       let numStr =               Strings.concat2 (Strings.concat2 intPart (Optionals.match fracPart "" Functions.identity)) (Optionals.match expPart "" Functions.identity)-      in (Parsers.pure (Model.ValueNumber (Optionals.match (Literals.parseDecimal numStr) (Literals.stringToDecimal "0.0") Functions.identity)))))))+      in (Parsers.pure (Model.ValueNumber (Optionals.match (Literals.parseDecimal numStr) (Literals.stringToDecimal "0") Functions.identity)))))))  -- | Parse a JSON object jsonObject :: Parsing.Parser Model.Value

@@ -100,7 +100,11 @@       Model.ValueNumber v0 ->         let rounded = Literals.decimalToBigint v0             shown = Literals.printDecimal v0-            isWhole = Equality.equal v0 (Literals.bigintToDecimal rounded)+            notExponential = Ordering.lte (Lists.length (Strings.splitOn "e" shown)) 1+            fracParts = Strings.splitOn "." shown+            frac = Optionals.withDefault "" (Lists.at 1 fracParts)+            isWhole =+                    Logic.and notExponential (Logic.or (Ordering.lte (Lists.length fracParts) 1) (Strings.isEmpty (Strings.concat (Strings.splitOn "0" frac))))             plain = Literals.printBigint rounded         in (Serialization.cst (Logic.ifElse (Logic.and isWhole (Ordering.lte (Strings.length plain) (Strings.length shown))) plain shown))       Model.ValueObject v0 -> Serialization.bracesListAdaptive (Lists.map keyValueToExpr v0)

@@ -49,7 +49,8 @@           "Alphabetic is broader than cased: letters in scripts without a case distinction are included. isAlphaNum is true whenever isAlpha is true.",           "Total. Corresponds to Haskell's Data.Char.isAlpha :: Char -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -77,7 +78,8 @@           "The classification is based on Unicode general categories (any of L*, Nd, Nl, No).",           "Total. Corresponds to Haskell's Data.Char.isAlphaNum :: Char -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -104,7 +106,8 @@           "Unlike the other predicates in this module, this one is deliberately ASCII-only: decimal digits outside the ASCII range (general category Nd) are rejected here, though isAlphaNum accepts them.",           "Total. Corresponds to Haskell's Data.Char.isDigit :: Char -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -132,7 +135,8 @@           "Note that not every letter is classified as uppercase or lowercase (e.g. titlecase letters, modifier letters, and letters in scripts without a case distinction are neither).",           "Total. Corresponds to Haskell's Data.Char.isLower :: Char -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -159,7 +163,8 @@           "The whitespace set follows Haskell's Data.Char.isSpace, which recognises U+0020 (space), U+0009 (tab), U+000A (line feed), U+000B (vertical tab), U+000C (form feed), U+000D (carriage return), U+00A0 (no-break space), and other Unicode characters with general category Zs, Zl, or Zp.",           "Total. Corresponds to Haskell's Data.Char.isSpace :: Char -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -187,7 +192,8 @@           "Note that titlecase letters (Lt) are not classified as uppercase by this predicate.",           "Total. Corresponds to Haskell's Data.Char.isUpper :: Char -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -215,7 +221,8 @@           "The argument is interpreted as a Unicode code point.",           "Total. Corresponds to Haskell's Data.Char.toLower :: Char -> Char."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -243,7 +250,8 @@           "The argument is interpreted as a Unicode code point.",           "Total. Corresponds to Haskell's Data.Char.toUpper :: Char -> Char."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [

@@ -46,7 +46,8 @@         Packaging.entityMetadataComments = [           "apply(ef, ex) describes an effectful computation which first interprets ef to produce a function, then interprets ex to produce an argument, and returns the result of applying the function to the argument."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -85,7 +86,8 @@           "bind(e, f) describes an effectful computation which first interprets e, then passes its result to f to obtain the next effect.",           "Host interpreters provide the operational meaning; Hydra uses the type effect<t> to keep the effect boundary explicit."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -123,7 +125,8 @@         Packaging.entityMetadataComments = [           "compose(f, g, x) describes an effectful computation equivalent to bind(f(x), g)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -171,7 +174,8 @@         Packaging.entityMetadataComments = [           "foldList(f, acc0, xs) describes an effectful left fold over xs, sequencing applications of f from left to right."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -217,7 +221,8 @@           "map(f, e) describes an effectful computation which interprets e and applies f to its result.",           "Equivalent to bind(e, \\x -> pure(f x))."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -255,7 +260,8 @@         Packaging.entityMetadataComments = [           "mapList(f, xs) describes an effectful computation which applies f to each element of xs from left to right and collects the results."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -293,7 +299,8 @@         Packaging.entityMetadataComments = [           "mapOptional(f, m) describes an effectful computation which returns none when m is none, or applies f to the contained value and wraps the result in given."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -332,7 +339,8 @@           "mapSet(f, s) describes an effectful computation which applies f to each element of s, sequencing the effects in ascending element order (the order is normative, since the effects are observable), and collects the results as a set, deduplicated by the result type's ordering.",           "Requires 'ordering' constraints on both element types (the set type contract)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -372,7 +380,8 @@         Packaging.entityMetadataComments = [           "pure(x) describes an effectful computation which succeeds with x without requiring host interaction."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {

@@ -49,7 +49,8 @@           "apply(ef, ex) is bind(ef, \\f -> map(f, ex)); this defining equation is the specification, and the default implementation.",           "Total. Corresponds to Haskell's (<*>) :: Either a (b -> c) -> Either a b -> Either a c."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -114,7 +115,8 @@           "bimap(f, g, e) applies f to the contained value if e is a Left, or g if e is a Right; the result retains the same Left/Right variant.",           "Total. Corresponds to Haskell's Data.Bifunctor.bimap :: (a -> c) -> (b -> d) -> Either a b -> Either c d."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -196,7 +198,8 @@           "Used to chain computations that may fail with a common error type.",           "Total. Corresponds to Haskell's (>>=) :: Either a b -> (b -> Either a c) -> Either a c."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -260,7 +263,8 @@           "If either f(x) or the second stage produces a left, the result is that left.",           "Total. Corresponds to Kleisli composition (>=>) specialised to Either with a fixed Left type."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -337,7 +341,8 @@         Packaging.entityMetadataSeeAlso = [],         Packaging.entityMetadataLifecycle = (Just (Packaging.LifecycleInfo {           Packaging.lifecycleInfoAvailableSince = Nothing,-          Packaging.lifecycleInfoDeprecatedSince = (Just (Packaging.Version "0.18"))}))})),+          Packaging.lifecycleInfoDeprecatedSince = (Just (Packaging.Version "0.18"))})),+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -388,7 +393,8 @@           "foldList(f, acc0, xs) folds f over xs from the left, threading an accumulator of type a, where each application may fail with Left e: it iterates while f returns Right, propagates Left on the first failure, and returns Right (final accumulator) if all elements were processed.",           "Corresponds to a short-circuiting variant of Haskell's foldM specialised to Either."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -473,7 +479,8 @@           "True if the argument is a Left variant, false if a Right.",           "Total. Corresponds to Haskell's Data.Either.isLeft :: Either a b -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -522,7 +529,8 @@           "True if the argument is a Right variant, false if a Left.",           "Total. Corresponds to Haskell's Data.Either.isRight :: Either a b -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -571,7 +579,8 @@           "left(x) is Left x. The dual constructor to right, injecting into the Left (error/exceptional) side of an either.",           "Total. Corresponds to Haskell's Left :: a -> Either a b."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -605,7 +614,8 @@           "lefts(xs) returns a list containing every Left value in xs, in original order, with Right values discarded.",           "Total. Corresponds to Haskell's Data.Either.lefts :: [Either a b] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -671,7 +681,8 @@           "The functor instance for either; treats the Right variant as the focus and leaves the Left variant alone.",           "Total. Corresponds to Haskell's fmap :: (a -> b) -> Either e a -> Either e b."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -737,7 +748,8 @@           "mapList(f, xs) applies f to each element of xs. If every application returns Right, the result is Right of the list of contained values, in original order. The first application that returns Left short-circuits the whole result to that Left.",           "Total. Corresponds to Haskell's traverse :: (a -> Either e b) -> [a] -> Either e [b]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -821,7 +833,8 @@           "mapOptional(f, m) returns Right none if m is none; otherwise applies f to the contained value and returns the result with Right wrapped around given.",           "Total. Corresponds to Haskell's traverse :: (a -> Either e b) -> Maybe a -> Either e (Maybe b)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -892,7 +905,8 @@           "Requires an 'ordering' constraint on the input and output element types.",           "Total. Corresponds to Haskell's traverse-style operation specialised to Set."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -989,7 +1003,8 @@           "partition(xs) returns a pair (lefts, rights) where lefts contains every Left value from xs in original order and rights contains every Right value from xs in original order.",           "Total. Corresponds to Haskell's Data.Either.partitionEithers :: [Either a b] -> ([a], [b])."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1072,7 +1087,8 @@           "right(x) is Right x. The dual constructor to left, injecting into the Right (success/normal) side of an either.",           "Total. Corresponds to Haskell's Right :: b -> Either a b."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1106,7 +1122,8 @@           "rights(xs) returns a list containing every Right value in xs, in original order, with Left values discarded.",           "Total. Corresponds to Haskell's Data.Either.rights :: [Either a b] -> [b]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {

@@ -49,7 +49,8 @@           "Equality is reflexive, symmetric, and transitive (no NaN-style exception on floating-point: floating-point equality is provided per the underlying host's IEEE 754 comparison rules, so NaN /= NaN at the level of float64/float32).",           "Total. Corresponds to Haskell's (==) :: Eq a => a -> a -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -85,7 +86,8 @@           "Requires an 'equality' type-class constraint on the argument type.",           "Total. Corresponds to Haskell's (/=) :: Eq a => a -> a -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {

@@ -46,7 +46,8 @@         Packaging.entityMetadataComments = [           "appendFile(path, contents) describes an effectful computation which attempts to append the raw bytes contents to the end of the file at path, creating the file if it does not exist. Unlike writeFile, existing contents are preserved. File I/O is byte-oriented; to append text, encode it to bytes first (e.g. via hydra.lib.text.encodeUtf8). A recoverable file-system failure is returned as left(error); success is returned as right(unit)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -81,7 +82,8 @@         Packaging.entityMetadataSeeAlso = [],         Packaging.entityMetadataLifecycle = (Just (Packaging.LifecycleInfo {           Packaging.lifecycleInfoAvailableSince = Nothing,-          Packaging.lifecycleInfoDeprecatedSince = (Just (Packaging.Version "0.18"))}))})),+          Packaging.lifecycleInfoDeprecatedSince = (Just (Packaging.Version "0.18"))})),+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -118,7 +120,8 @@         Packaging.entityMetadataComments = [           "createDirectory(recursive, path) describes an effectful computation which attempts to create a directory at path. When recursive is false this corresponds to POSIX mkdir: it fails if path already exists or if a parent is missing. When recursive is true, any missing parent directories are created as well (as with mkdir -p) and an already-existing directory is not an error. A recoverable file-system failure is returned as left(error); success is returned as right(unit)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -150,7 +153,8 @@         Packaging.entityMetadataComments = [           "createSymlink(target, link) describes an effectful computation which attempts to create a symbolic link at link, pointing to target (POSIX symlink). target is stored verbatim; it may be a relative path, and it need not exist. There is no force flag: if link already exists (including as a dangling symbolic link), the computation fails with left(alreadyExists); a caller that wants replace-if-exists semantics should compose status(false, link), removeFile, and createSymlink. A missing parent directory yields left(notFound); a host or file system which refuses to create the link (e.g. an unprivileged process on Windows, or an unsupported file system) yields left(permissionDenied) or left(other) as appropriate. A recoverable file-system failure is returned as left(error); success is returned as right(unit)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -182,7 +186,8 @@         Packaging.entityMetadataComments = [           "exists(path) describes an effectful computation which reports whether anything exists at path, whether a file, directory, or other type of file. It does not error when the path is absent; a missing path is reported as right(false). Use status to obtain the type of an existing path. A recoverable file-system failure is returned as left(error)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -209,7 +214,8 @@         Packaging.entityMetadataComments = [           "listDirectory(path) describes an effectful computation which returns the immediate entries of the directory at path, excluding the special entries \".\" and \"..\". The result is one level deep and is not ordered; to traverse a tree recursively, recurse using status. A recoverable file-system failure is returned as left(error)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -236,7 +242,8 @@         Packaging.entityMetadataComments = [           "readFile(path) describes an effectful computation which attempts to read the entire contents of the file at path as raw bytes, with no character decoding or newline translation. To interpret the result as text, decode it (e.g. via hydra.lib.text.decodeUtf8). A recoverable file-system failure is returned as left(error); success is returned as right(contents)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -263,7 +270,8 @@         Packaging.entityMetadataComments = [           "readSymlink(path) describes an effectful computation which attempts to read the target of the symbolic link at path (POSIX readlink). This is a single-hop, unresolved read: the target is returned exactly as stored, with no chain resolution or canonicalization; a relative target is returned relative, and a dangling target (one that does not exist) is returned as-is. To resolve a chain of links to a canonical path, compose repeated calls to readSymlink and status. A missing path yields left(notFound); a path which exists but is not a symbolic link yields left(invalidPath). A recoverable file-system failure is returned as left(error); success is returned as right(target)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -290,7 +298,8 @@         Packaging.entityMetadataComments = [           "removeDirectory(recursive, path) describes an effectful computation which attempts to remove the directory at path. When recursive is false this corresponds to POSIX rmdir: it fails unless the directory is empty. When recursive is true, the directory and its entire contents are removed (as with rm -r). Removal is performed by the host operating system rather than by walking and deleting entries individually. A recoverable file-system failure is returned as left(error); success is returned as right(unit)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -322,7 +331,8 @@         Packaging.entityMetadataComments = [           "removeFile(path) describes an effectful computation which attempts to remove the file at path (POSIX unlink). A recoverable file-system failure is returned as left(error); success is returned as right(unit)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -349,7 +359,8 @@         Packaging.entityMetadataComments = [           "rename(source, destination) describes an effectful computation which attempts to rename the file or directory at source to destination. When source and destination are on the same file system this is atomic (POSIX rename) and cannot be reproduced by a copy followed by a delete. A recoverable file-system failure is returned as left(error); success is returned as right(unit)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -381,7 +392,8 @@         Packaging.entityMetadataComments = [           "status(followLinks, path) describes an effectful computation which retrieves metadata about the file system entry at path, including its type, size, and modification time. When followLinks is true, this corresponds to POSIX stat: if path is a symbolic link, the metadata describes the link's target, and a dangling link (whose target does not exist) yields left(notFound). When followLinks is false, this corresponds to POSIX lstat: the metadata describes the link itself, with fileType link, a size equal to the length of the stored target path, and the link's own timestamps; a dangling link is not an error in this mode. status(false, path) is the only way to observe fileType link; status(true, path) never produces it, since a followed link's metadata is always that of its (non-link) target. For paths that are not symbolic links, both modes report identical metadata. A path which does not exist yields left(notFound); other recoverable file-system failures are also returned as left(error). Use exists for a boolean presence check that does not error on absence."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -413,7 +425,8 @@         Packaging.entityMetadataComments = [           "writeFile(path, contents) describes an effectful computation which attempts to replace the file at path with the raw bytes contents, with no character encoding or newline translation. To write text, encode it to bytes first (e.g. via hydra.lib.text.encodeUtf8). A recoverable file-system failure is returned as left(error); success is returned as right(unit)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [

@@ -49,7 +49,8 @@           "The eliminator dual to the (nonexistent) introducer for void.",           "Total, vacuously: there is no well-typed argument on which absurd could be called. Corresponds to Haskell's Data.Void.absurd :: Void -> a."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -80,7 +81,8 @@           "This is ordinary function composition, distinct from the Kleisli compose primitives of the monad modules.",           "Total. Corresponds to Haskell's (.) :: (b -> c) -> (a -> b) -> a -> c."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -143,7 +145,8 @@           "Partially applied, const(x) is the constant function which returns x on every input.",           "Total. Corresponds to Haskell's const :: a -> b -> a."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -186,7 +189,8 @@           "flip(f, x, y) = f(y, x); this defining equation is the specification.",           "Total. Corresponds to Haskell's flip :: (a -> b -> c) -> b -> a -> c."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -249,7 +253,8 @@           "identity is the unit of compose: compose(identity, f) and compose(f, identity) are both f.",           "Total. Corresponds to Haskell's id :: a -> a."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {

@@ -47,7 +47,8 @@           "sha256(bytes) returns the 32-byte SHA-256 digest of bytes. Total: hashing is pure and never fails.",           "Pairs with hydra.lib.files.readFile, which returns raw bytes, to hash file contents."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -73,7 +74,8 @@           "sha256Hex(bytes) returns the SHA-256 digest of bytes as a 64-character lowercase hexadecimal string. Equivalent to hex-encoding the output of sha256. Total: hashing is pure and never fails.",           "Pairs with hydra.lib.files.readFile, which returns raw bytes, to hash file contents."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [

@@ -48,7 +48,8 @@           "Equivalent to the applicative list instance.",           "Total. Corresponds to Haskell's (<*>) :: [a -> b] -> [a] -> [b]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -87,7 +88,8 @@           "at(i, xs) returns Just(xs[i]) if 0 <= i < length(xs), or Nothing otherwise.",           "Total. Wraps the Haskell (!!) operator, which is partial, in maybe to make out-of-bounds total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -121,7 +123,8 @@           "bind(xs, f) applies f to each element of xs and concatenates the resulting lists in order. Equivalent to concatMap.",           "Total. Corresponds to Haskell's (>>=) :: [a] -> (a -> [b]) -> [b]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -184,7 +187,8 @@           "compose(f, g, x) is bind(f(x), g); this defining equation is the specification. The results of applying g to each element of f(x) are concatenated in order.",           "Total. Corresponds to Kleisli composition (>=>) in the list monad."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -233,7 +237,8 @@           "concat(xss) returns the list obtained by appending all the lists in xss in order.",           "Total. Corresponds to Haskell's concat :: [[a]] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -262,7 +267,8 @@           "concat2(xs, ys) returns xs with ys appended.",           "Total. Corresponds to Haskell's (++) :: [a] -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -296,7 +302,8 @@           "cons(x, xs) returns a list whose head is x and whose tail is xs.",           "Total. Corresponds to Haskell's (:) :: a -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -331,7 +338,8 @@           "Requires an 'equality' constraint on the element type.",           "Total. Corresponds to Haskell's Data.List.nub :: Eq a => [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -361,7 +369,8 @@           "drop(n, xs) returns the suffix of xs after dropping the first n elements; if n is greater than or equal to length(xs) the result is the empty list; if n is non-positive the result is xs unchanged.",           "Total. Corresponds to Haskell's drop :: Int -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -395,7 +404,8 @@           "dropWhile(p, xs) returns the suffix of xs starting at the first element for which p returns false. If p is true for every element, the result is the empty list.",           "Total. Corresponds to Haskell's dropWhile :: (a -> Bool) -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -443,7 +453,8 @@           "filter(p, xs) returns the list of elements x in xs for which p(x) is true, in original order.",           "Total. Corresponds to Haskell's filter :: (a -> Bool) -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -509,7 +520,8 @@           "find(p, xs) returns Just(x) where x is the first element of xs for which p(x) is true, or Nothing if no such element exists.",           "Total. Corresponds to Haskell's find :: (a -> Bool) -> [a] -> Maybe a."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -572,7 +584,8 @@           "foldList(f, acc0, xs) is foldl(\\macc el -> bind(macc, \\acc -> f(acc, el)), singleton(acc0), xs); this defining equation is the specification. For the empty list the result is singleton(acc0).",           "Total on finite inputs. The list-monad instance of the monadic left fold."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -619,7 +632,8 @@           "Strict in the accumulator on hosts where laziness would otherwise leak space.",           "Total on finite inputs. Corresponds to Haskell's foldl' :: (b -> a -> b) -> b -> [a] -> b."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -665,7 +679,8 @@           "foldr(f, acc0, xs) reduces xs right-associatively: foldr(f, acc0, [x1, ..., xn]) = f(x1, f(x2, ..., f(xn, acc0))). For the empty list the result is acc0.",           "Total on finite inputs. Corresponds to Haskell's foldr :: (a -> b -> b) -> b -> [a] -> b."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -712,7 +727,8 @@           "Equality is determined by the element type's 'equality' constraint.",           "Total. Corresponds to Haskell's Data.List.group :: Eq a => [a] -> [[a]]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -742,7 +758,8 @@           "head(xs) returns Just(x) where x is the first element of xs, or Nothing if xs is empty.",           "Total. Wraps Haskell's partial head in maybe."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -771,7 +788,8 @@           "init(xs) returns Just(ys) where ys is xs with its last element removed, or Nothing if xs is empty.",           "Total. Wraps Haskell's partial init in maybe."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -800,7 +818,8 @@           "intersperse(sep, xs) returns xs with sep inserted between each pair of adjacent elements; for lists of length 0 or 1 the input is returned unchanged.",           "Total. Corresponds to Haskell's intersperse :: a -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -834,7 +853,8 @@           "isEmpty(xs) returns true iff xs is the empty list.",           "Total. Corresponds to Haskell's null :: [a] -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -863,7 +883,8 @@           "join(sep, xss) returns the concatenation of xss with sep inserted between consecutive lists. Equivalent to concat(intersperse(sep, xss)).",           "Total. Corresponds to Haskell's intercalate :: [a] -> [[a]] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -897,7 +918,8 @@           "last(xs) returns Just(x) where x is the last element of xs, or Nothing if xs is empty.",           "Total. Wraps Haskell's partial last in maybe."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -927,7 +949,8 @@           "Total on finite inputs; the int32 result overflows for lists longer than 2^31-1 elements.",           "Corresponds to Haskell's length :: [a] -> Int (with narrowing to Int32)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -956,7 +979,8 @@           "map(f, xs) returns the list of f(x) for each x in xs, in original order.",           "Total. Corresponds to Haskell's map :: (a -> b) -> [a] -> [b] / fmap on lists."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -996,7 +1020,8 @@           "Results appear in the lexicographic order of the choices, with the choice for the first element varying slowest. The number of results is the product of the lengths of the lists f(x); if f(x) is empty for any element, the result is the empty list; mapList(f, []) is singleton([]).",           "Total on finite inputs. The list-monad instance of the traversal family."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1035,7 +1060,8 @@           "mapOptional(f, m) returns the single-element list containing none when m is none; for given(x) it returns given(y) for each element y of f(x), in order.",           "Total on finite inputs. The list-monad instance of the traversal family, applied to the optional container."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1075,7 +1101,8 @@           "A result set may have fewer elements than s when distinct choices coincide. If f(x) is empty for any element, the result is the empty list; for the empty set the result is the single-element list containing the empty set.",           "Requires 'ordering' constraints on both element types (the set type contract)."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1117,7 +1144,8 @@           "Requires an 'equality' constraint on the element type.",           "Total. Corresponds to Haskell's elem :: Eq a => a -> [a] -> Bool."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1152,7 +1180,8 @@           "partition(p, xs) returns a pair (yes, no) where yes is the list of elements of xs for which p is true and no is the list of elements for which p is false, each preserving original order.",           "Total. Corresponds to Haskell's partition :: (a -> Bool) -> [a] -> ([a], [a])."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1236,7 +1265,8 @@           "replicate(n, x) returns a list of n copies of x; for n <= 0 the result is the empty list.",           "Total. Corresponds to Haskell's replicate :: Int -> a -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1270,7 +1300,8 @@           "reverse(xs) returns the elements of xs in reverse order.",           "Total. Corresponds to Haskell's reverse :: [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1300,7 +1331,8 @@           "The constructor for a single-element list; useful point-free (e.g. map singleton xs).",           "Total. Corresponds to Haskell's singleton :: a -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1330,7 +1362,8 @@           "Requires an 'ordering' constraint on the element type.",           "Total. Corresponds to Haskell's Data.List.sort :: Ord a => [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1361,7 +1394,8 @@           "Requires an 'ordering' constraint on the key type.",           "Total. Corresponds to Haskell's Data.List.sortOn :: Ord b => (a -> b) -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1401,7 +1435,8 @@           "span(p, xs) returns a pair (ys, zs) where ys is the longest prefix of xs whose elements all satisfy p, and zs is the remainder of xs starting at the first element that fails p (or zs is empty if all elements satisfy p).",           "Total. Corresponds to Haskell's span :: (a -> Bool) -> [a] -> ([a], [a])."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1495,7 +1530,8 @@           "tail(xs) returns Just(ys) where ys is xs with its first element removed, or Nothing if xs is empty.",           "Total. Wraps Haskell's partial tail in maybe."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1524,7 +1560,8 @@           "take(n, xs) returns the prefix of xs of length min(n, length(xs)); if n is non-positive the result is the empty list.",           "Total. Corresponds to Haskell's take :: Int -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1559,7 +1596,8 @@           "dropWhile returns the complementary suffix, and span(p, xs) returns the pair of takeWhile(p, xs) and dropWhile(p, xs).",           "Total. Corresponds to Haskell's takeWhile :: (a -> Bool) -> [a] -> [a]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1607,7 +1645,8 @@           "transpose(xss) returns a list of lists where the i-th inner list contains the i-th element of every inner list of xss that has at least i+1 elements. Inner lists of differing lengths produce a ragged result rather than an error.",           "Total. Corresponds to Haskell's Data.List.transpose :: [[a]] -> [[a]]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1636,7 +1675,8 @@           "uncons(xs) returns Just(head, tail) where head is the first element of xs and tail is the remaining list, or Nothing if xs is empty.",           "Total. Corresponds to Haskell's Data.List.uncons :: [a] -> Maybe (a, [a])."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1667,7 +1707,8 @@           "zip(xs, ys) returns the list of pairs (xs[i], ys[i]) for i from 0 to min(length(xs), length(ys))-1. The result has length equal to the shorter of the two inputs.",           "Total. Corresponds to Haskell's zip :: [a] -> [b] -> [(a, b)]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {@@ -1706,7 +1747,8 @@           "zipWith(f, xs, ys) returns the list of f(xs[i], ys[i]) for i from 0 to min(length(xs), length(ys))-1. The result has length equal to the shorter of the two inputs.",           "Total. Corresponds to Haskell's zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [           Typing.TypeParameter {

@@ -47,7 +47,8 @@           "base64ToBinary(s) decodes the standard base64 (RFC 4648) ASCII string s and returns the resulting bytes as binary data.",           "Inverse of binaryToBase64: base64ToBinary(binaryToBase64(b)) is b for every binary value. Behavior on strings which are not valid base64 is host-defined."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -73,7 +74,8 @@           "bigintToDecimal(x) returns the exact decimal representation of x. Since decimal is arbitrary-precision and bigint is also arbitrary-precision, the conversion is lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -99,7 +101,8 @@           "bigintToInt16(x) returns x reduced modulo 2^16 and reinterpreted as a signed two's-complement int16. Values outside [-2^15, 2^15-1] wrap silently with no exception.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -125,7 +128,8 @@           "bigintToInt32(x) returns x reduced modulo 2^32 and reinterpreted as a signed two's-complement int32. Values outside [-2^31, 2^31-1] wrap silently with no exception.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -151,7 +155,8 @@           "bigintToInt64(x) returns x reduced modulo 2^64 and reinterpreted as a signed two's-complement int64. Values outside [-2^63, 2^63-1] wrap silently with no exception.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -177,7 +182,8 @@           "bigintToInt8(x) returns x reduced modulo 2^8 and reinterpreted as a signed two's-complement int8. Values outside [-128, 127] wrap silently with no exception.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -203,7 +209,8 @@           "bigintToUint16(x) returns x reduced modulo 2^16 as an unsigned uint16. Values outside [0, 2^16-1] wrap silently with no exception.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -229,7 +236,8 @@           "bigintToUint32(x) returns x reduced modulo 2^32 as an unsigned uint32. Values outside [0, 2^32-1] wrap silently with no exception.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -255,7 +263,8 @@           "bigintToUint64(x) returns x reduced modulo 2^64 as an unsigned uint64. Values outside [0, 2^64-1] wrap silently with no exception.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -281,7 +290,8 @@           "bigintToUint8(x) returns x reduced modulo 2^8 as an unsigned uint8. Values outside [0, 255] wrap silently with no exception.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -307,7 +317,8 @@           "binaryToBase64(b) encodes the bytes of b using standard base64 (RFC 4648) and returns the result as an ASCII string.",           "Total and round-trippable: base64ToBinary(binaryToBase64(b)) is b for every binary value. Use this to embed arbitrary binary data in a string context (e.g. a JSON value). For interpreting bytes as text, use hydra.lib.text.decodeUtf8 instead."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -334,7 +345,8 @@           "The result list element type is int32 rather than uint8 because Hydra's primitive collections work most naturally with int32 indices.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -360,7 +372,8 @@           "decimalToBigint(x) returns x truncated toward zero. Fractional parts are discarded.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -386,7 +399,8 @@           "decimalToFloat32(x) returns the IEEE 754 binary32 value closest to x under roundTiesToEven. Values outside the float32 representable range overflow to \177\8734. Subnormal precision loss is silent.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -412,7 +426,8 @@           "decimalToFloat64(x) returns the IEEE 754 binary64 value closest to x under roundTiesToEven. Values outside the float64 representable range overflow to \177\8734. Subnormal precision loss is silent.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -438,7 +453,8 @@           "float32ToDecimal(x) returns the exact decimal representation of the binary32 value x. Special float32 values (\177\8734, NaN) have a host-defined decimal representation; finite values convert exactly since binary32 values are dyadic rationals.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -464,7 +480,8 @@           "float32ToFloat64(x) returns the binary64 value with the same numeric value as x; \177\8734 and NaN pass through. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -490,7 +507,8 @@           "float64ToDecimal(x) returns the exact decimal representation of the binary64 value x. Special float64 values (\177\8734, NaN) have a host-defined decimal representation; finite values convert exactly since binary64 values are dyadic rationals.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -516,7 +534,8 @@           "float64ToFloat32(x) returns the binary32 value closest to x under roundTiesToEven. Values outside the binary32 range overflow to \177\8734; subnormal precision loss is silent; NaN payload may be canonicalized by the host.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -542,7 +561,8 @@           "int16ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -568,7 +588,8 @@           "int32ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -594,7 +615,8 @@           "int64ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -620,7 +642,8 @@           "int8ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -647,7 +670,8 @@           "Accepted syntax follows the Haskell Show/Read convention: an optional leading minus sign followed by a sequence of decimal digits. Whitespace is not stripped; leading or trailing whitespace causes parse failure.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -673,7 +697,8 @@           "parseBoolean(s) returns Just(true) for \"true\", Just(false) for \"false\", and Nothing for any other input (including \"True\"/\"False\" with capital initial letter on some hosts; behavior on capitalized forms is host-defined and should not be relied upon).",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -700,7 +725,8 @@           "Accepted syntax is the standard decimal literal: an optional sign, an integer part, an optional fractional part, and an optional exponent (e.g. -1.5, 2e10, 0.0).",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -727,7 +753,8 @@           "Accepted special-value literals (\"NaN\", \"Infinity\", \"-Infinity\", etc.) and their capitalization are host-defined.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -754,7 +781,8 @@           "Accepted special-value literals (\"NaN\", \"Infinity\", \"-Infinity\", etc.) and their capitalization are host-defined.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -780,7 +808,8 @@           "parseInt16(s) returns Just(x) where x is the int16 parsed from s, or Nothing if s is not a valid integer literal or the parsed value is outside [-2^15, 2^15-1].",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -806,7 +835,8 @@           "parseInt32(s) returns Just(x) where x is the int32 parsed from s, or Nothing if s is not a valid integer literal or the parsed value is outside [-2^31, 2^31-1].",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -832,7 +862,8 @@           "parseInt64(s) returns Just(x) where x is the int64 parsed from s, or Nothing if s is not a valid integer literal or the parsed value is outside [-2^63, 2^63-1].",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -858,7 +889,8 @@           "parseInt8(s) returns Just(x) where x is the int8 parsed from s, or Nothing if s is not a valid integer literal or the parsed value is outside [-128, 127].",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -884,7 +916,8 @@           "parseString(s) parses s as a Haskell-syntax string literal token: an opening double-quote, escaped characters per the Haskell lexical grammar (backslash escapes for special characters and Unicode code points), and a closing double-quote. Returns Just of the decoded payload on success or Nothing on malformed input.",           "Total. The inverse of printString."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -910,7 +943,8 @@           "parseUint16(s) returns Just(x) where x is the uint16 parsed from s, or Nothing if s is not a valid non-negative integer literal or the parsed value is outside [0, 2^16-1].",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -936,7 +970,8 @@           "parseUint32(s) returns Just(x) where x is the uint32 parsed from s, or Nothing if s is not a valid non-negative integer literal or the parsed value is outside [0, 2^32-1].",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -962,7 +997,8 @@           "parseUint64(s) returns Just(x) where x is the uint64 parsed from s, or Nothing if s is not a valid non-negative integer literal or the parsed value is outside [0, 2^64-1].",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -988,7 +1024,8 @@           "parseUint8(s) returns Just(x) where x is the uint8 parsed from s, or Nothing if s is not a valid non-negative integer literal or the parsed value is outside [0, 255].",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1014,7 +1051,8 @@           "printBigint(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits. No leading zeros are produced (except for the value 0 itself, which renders as \"0\").",           "Total. The inverse of parseBigint."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1040,7 +1078,8 @@           "printBoolean(true) = \"true\"; printBoolean(false) = \"false\".",           "Total. The inverse of parseBoolean."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1066,7 +1105,8 @@           "printDecimal(x) returns the canonical decimal representation of x as a string. The exact form (use of scientific notation, trailing zeros, etc.) is host-defined but always round-trips with parseDecimal.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1092,7 +1132,8 @@           "printFloat32(x) returns a string representation of x. Finite values use the shortest decimal that round-trips through parseFloat32 back to x. Special values render as \"NaN\", \"Infinity\", or \"-Infinity\" (capitalization is host-defined).",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1118,7 +1159,8 @@           "printFloat64(x) returns a string representation of x. Finite values use the shortest decimal that round-trips through parseFloat64 back to x. Special values render as \"NaN\", \"Infinity\", or \"-Infinity\" (capitalization is host-defined).",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1144,7 +1186,8 @@           "printInt16(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits.",           "Total. The inverse of parseInt16."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1170,7 +1213,8 @@           "printInt32(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits.",           "Total. The inverse of parseInt32."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1196,7 +1240,8 @@           "printInt64(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits.",           "Total. The inverse of parseInt64."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1222,7 +1267,8 @@           "printInt8(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits.",           "Total. The inverse of parseInt8."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1248,7 +1294,8 @@           "printString(s) returns a Haskell-syntax string literal token representing s: an opening double-quote, the characters of s with special characters escaped (backslash sequences for control characters, quotes, and non-printable Unicode code points), and a closing double-quote.",           "Total. The inverse of parseString."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1274,7 +1321,8 @@           "printUint16(x) returns the canonical decimal representation of x.",           "Total. The inverse of parseUint16."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1300,7 +1348,8 @@           "printUint32(x) returns the canonical decimal representation of x.",           "Total. The inverse of parseUint32."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1326,7 +1375,8 @@           "printUint64(x) returns the canonical decimal representation of x.",           "Total. The inverse of parseUint64."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1352,7 +1402,8 @@           "printUint8(x) returns the canonical decimal representation of x.",           "Total. The inverse of parseUint8."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1378,7 +1429,8 @@           "uint16ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1404,7 +1456,8 @@           "uint32ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1430,7 +1483,8 @@           "uint64ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [@@ -1456,7 +1510,8 @@           "uint8ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",           "Total."],         Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.entityMetadataLifecycle = Nothing,+        Packaging.entityMetadataProvisions = []})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [