hydra-haskell 0.17.0 → 0.17.1

raw patch · 6 files changed

+802/−410 lines, 6 filesdep ~hydra-kernelPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hydra-kernel

API changes (from Hackage documentation)

Files

• CHANGELOG.md +139/−0
• hydra-haskell.cabal +2/−2
• src/main/haskell/Hydra/Dsl/Haskell/Environment.hs +4/−0
• src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs +245/−0
• src/main/haskell/Hydra/Haskell/Coder.hs +6/−2
• src/main/haskell/Hydra/Haskell/Syntax.hs +406/−406

@@ -15,6 +15,145 @@  --- +## [0.17.1] - unreleased++Development version. Opens the 0.17.x line — the first release built entirely against+published 0.17.0 hosts (Hackage / PyPI / Maven Central), with the `hostOverrides` shims+that were needed while 0.16.1 lacked the effect type and I/O primitives removed.++### New features++- **Generated term-reference DSLs** ([#467](https://github.com/CategoricalData/hydra/issues/467)):+  kernel *term* modules now project generated DSL surfaces, completing the story begun with+  type-module DSLs and the generated primitive wrappers (`hydra.dsl.lib.*`, 0.17.0). A+  signature read-back in the DSL pass reuses the main pass's inference, and a demand-curated+  set of 19 kernel term modules (plus the json/test/extract modules) emits one typed,+  rename-safe reference per definition into every target language — e.g. Haskell+  `Hydra.Dsl.Strip.deannotateType`, Java `hydra.dsl.Strip.deannotateType(...)`, Python+  `hydra.dsl.strip.deannotate_type(...)`. The Java and Python coder sources were pivoted onto+  the generated references, retiring ~700 stringly-typed inline `var("hydra....")` references+  and shrinking Python's hand registry to the non-generatable remainder (byte-identical+  generated output before and after). Follow-ups:+  [#555](https://github.com/CategoricalData/hydra/issues/555) (typed references to derived+  encode/decode/show functions via `TypedName`),+  [#556](https://github.com/CategoricalData/hydra/issues/556) (non-kernel packages).+- **Package validation** ([#574](https://github.com/CategoricalData/hydra/issues/574),+  [#575](https://github.com/CategoricalData/hydra/issues/575)): a translingual `hydra.validate.*`+  framework carries per-package `ValidationProfile`s (error/warning rules, error/warning caps) and a+  catalog of checks — undeclared-package-dependency detection (now a fatal gate, #574),+  definition-name convention (PascalCase), definition ordering, documentation completeness, and+  conflicting-variant-name detection — layered on the existing core term/type well-formedness rules.+  A kernel-strict / others-relaxed policy keeps `/sync` green fleet-wide while the documentation+  backlog drains. See the new [Validation](https://github.com/CategoricalData/hydra/wiki/Validation)+  wiki page for the full per-package constraint specification.+- **DSL-authoring registration guards** ([#554](https://github.com/CategoricalData/hydra/issues/554)):+  fail-fast authoring-time validation for the host-native DSL sources — every DSL-authoring module in+  Java/`hydra-jvm`, Python, and Scala now asserts its definitions are fully registered+  (`Defs.checkComplete` / `check_complete`), backed by a Haskell kernel-source registration-completeness+  scanner, so a definition added to a source file but omitted from its `definitions` list fails loudly+  instead of silently vanishing from the generated output.+- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546),+  [#529](https://github.com/CategoricalData/hydra/issues/529),+  [#530](https://github.com/CategoricalData/hydra/issues/530)): the build-orchestration logic that had+  lived only in host scripts is now translingual Hydra. Pure module-list utilities became+  `hydra.build.modules` (#529) and the orphan-reconcile decision became `hydra.build.reconcile` (#530),+  each with a translingual test suite; the `hydra.build.*` modules were then extracted into a dedicated+  `hydra-build` package (#546), separate from the kernel.+- **Metadata sidecar + content/version-addressed freshness**+  ([#415](https://github.com/CategoricalData/hydra/issues/415)): dist manifests now carry a+  `moduleFormatVersion` field, and the generator's freshness basis is content/version-addressed — the+  groundwork for reproducible, cache-correct incremental generation.+- **Structured generation-provenance record**+  ([#523](https://github.com/CategoricalData/hydra/issues/523)): each generation run now records a+  structured `Generation` provenance entry (digest v2), replacing the ad-hoc shell threading of+  generation metadata.+- **Worker + issue hierarchy** ([#557](https://github.com/CategoricalData/hydra/issues/557)): a+  principled agent/worker framework — roles and parentage mirroring the GitHub issue tree, a+  cross-worktree message transport with a verify-after-copy protocol, a blocking-aware design-question+  (`decisions/`) channel, an issue-proposal queue with the `/issues` command, an autonomy-dial banner,+  and cross-machine staging coordination. Contributor-facing process only; no change to generated code.++### API and usability++- **DSL usability passes** ([#430](https://github.com/CategoricalData/hydra/issues/430),+  [#553](https://github.com/CategoricalData/hydra/issues/553)): reviewed the host-native Java, Python,+  and Scala DSL surfaces for ergonomics and cross-host parity (documented def shapes, added a Scala+  projection helper), bringing the three authoring dialects into closer alignment.++### Fixed++Bug fixes landed this cycle, grouped by area (see each issue for detail):++- **TypeScript** — reactivated `hydra.lib.*` primitive tests surfaced encoder gaps: lazy show-calling+  let bindings and compact bare-string `LiteralType` expansion in the test converter+  ([#564](https://github.com/CategoricalData/hydra/issues/564)),+  `binaryToBytes` registration + base64 binary decode in `decodeUtf8`+  ([#561](https://github.com/CategoricalData/hydra/issues/561)),+  `hydra.test.build.*` emission after the #546 split+  ([#570](https://github.com/CategoricalData/hydra/issues/570)), and `HYDRA_DEFAULT_IMPLS` support in+  the test runner ([#536](https://github.com/CategoricalData/hydra/issues/536)).+- **Tests and CI** — restored the default-primitive-implementation testing solution+  ([#388](https://github.com/CategoricalData/hydra/issues/388),+  [#549](https://github.com/CategoricalData/hydra/issues/549)), reactivated previously-ignored kernel+  test cases ([#513](https://github.com/CategoricalData/hydra/issues/513),+  [#550](https://github.com/CategoricalData/hydra/issues/550)), wired the regression harnesses into CI+  and split them out of the monolithic Haskell job for timeout headroom+  ([#535](https://github.com/CategoricalData/hydra/issues/535),+  [#563](https://github.com/CategoricalData/hydra/issues/563)), added Scala/Go/Lisp+  self-containment gates to `verify-distribution.sh`+  ([#537](https://github.com/CategoricalData/hydra/issues/537)), a manifest-JSON-tracked CI check+  ([#541](https://github.com/CategoricalData/hydra/issues/541)), a per-package test-digest freshness+  fix ([#551](https://github.com/CategoricalData/hydra/issues/551)), overlay-file restoration in+  `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)), and a+  sync-freshness fingerprint that now sees host-native DSL sources+  ([#562](https://github.com/CategoricalData/hydra/issues/562)).+- **Kernel and coders** — Java binary-literal signed-byte emission+  ([#528](https://github.com/CategoricalData/hydra/issues/528)), `hydra.json.Decode.fromJson`+  parametric-type (Application/Forall) support+  ([#531](https://github.com/CategoricalData/hydra/issues/531)), stale 2-param `Coder` shape in+  Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552)), and a+  kernel dead-code/TODO cleanup ([#538](https://github.com/CategoricalData/hydra/issues/538)).+- **Lib and build** — `hydra.lib.files` copy/removeDirectory/status overlays across all nine hosts+  ([#525](https://github.com/CategoricalData/hydra/issues/525)), `hydra.build.*` regeneration into the+  Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)), Scheme maps+  last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)),+  standalone-kernel SHA dependency ([#542](https://github.com/CategoricalData/hydra/issues/542)),+  the lexicon's empty Types section ([#539](https://github.com/CategoricalData/hydra/issues/539)), and+  a duplicated generated-file header in `generate-head-haskell-build.py`+  ([#540](https://github.com/CategoricalData/hydra/issues/540)).++- **TypeScript overlay-import rewrite** ([#565](https://github.com/CategoricalData/hydra/issues/565)):+  the TypeScript coder's lib overlay-import rewrite no longer captures `hydra.lib.defaults`, which is a+  generated (not overlaid) module; excluding it fixes spurious import references in generated TypeScript.++- **Lexicon generation** (`bin/regenerate-lexicon.sh`): the generator had been failing+  silently since the encoder/decoder modules moved to in-memory synthesis+  ([#448](https://github.com/CategoricalData/hydra/issues/448)) — the script masked the+  failure and left a stale `docs/hydra-lexicon.txt` missing the four effectful primitive+  libraries (`hydra.lib.{effects,files,system,text}`). The synthesized coder modules are+  now included in the lexicon universe, the script fails loudly, and the regenerated+  lexicon covers all 267 primitives across 17 library modules.+- **`bin/prepare-release.sh`**: the non-blocking Java quality check invoked Gradle+  subprojects (`:hydra-rdf4j:test` etc.) that were removed in+  [#511](https://github.com/CategoricalData/hydra/issues/511), so it always warned without+  checking anything; it now runs the `dist/java/hydra-pg` package tests (the current home+  of the former binding tests).+- **`.gitignore`**: the ignore rules for the overlaid hand-written Haskell runtime still+  named pre-[#501](https://github.com/CategoricalData/hydra/issues/501) paths, so 41+  duplicate copies under `dist/haskell/` had become tracked; the rules now match the+  `Hydra/Overlay/` location and the duplicates are untracked.++### Documentation++- Corrected the 0.17.0 Maven coordinates throughout (Java artifacts publish under group+  `net.fortytwo.hydra.java`, Scala under `net.fortytwo.hydra.scala`,+  [#519](https://github.com/CategoricalData/hydra/issues/519)); added the npm and Scala+  release channels to the README; added TypeScript/Scala/Lisp sections to Getting started;+  repointed stale pre-#418/#501 DSL paths in the architecture docs; added GitHub issue and+  PR templates.++---+ ## [0.17.0] - 2026-07-01  Major themes: first-class support for effects and I/O in the kernel, TypeScript and

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-haskell-version:        0.17.0+version:        0.17.1 synopsis:       Hydra's Haskell coder: emit Haskell source from Hydra modules 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 Hydra's Haskell coder: it translates Hydra modules into Haskell source. The top-level entry point is moduleToHaskell (and moduleToHaskellModule for the structured AST). It builds on hydra-kernel. category:       Data@@ -44,6 +44,6 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-kernel ==0.17.0+    , hydra-kernel ==0.17.1     , scientific >=0.3.7 && <0.4   default-language: Haskell2010

@@ -29,6 +29,10 @@           Core.fieldName = (Core.Name "usesSet"),           Core.fieldTerm = (Typed.unTypedTerm usesSet)}]})) +-- | DSL name token for hydra.haskell.environment.HaskellModuleMetadata+haskellModuleMetadataHaskellModuleMetadata :: Typed.TypedName Environment.HaskellModuleMetadata+haskellModuleMetadataHaskellModuleMetadata = Typed.TypedName (Core.Name "hydra.haskell.environment.HaskellModuleMetadata")+ -- | DSL accessor for the usesByteString field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataUsesByteString :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool haskellModuleMetadataUsesByteString x =

@@ -27,6 +27,10 @@           Core.fieldName = (Core.Name "binds"),           Core.fieldTerm = (Typed.unTypedTerm binds)}]})) +-- | DSL name token for hydra.haskell.syntax.Alternative+alternativeAlternative :: Typed.TypedName Syntax.Alternative+alternativeAlternative = Typed.TypedName (Core.Name "hydra.haskell.syntax.Alternative")+ -- | DSL accessor for the binds field of hydra.haskell.syntax.Alternative alternativeBinds :: Typed.TypedTerm Syntax.Alternative -> Typed.TypedTerm (Maybe Syntax.LocalBindings) alternativeBinds x =@@ -139,6 +143,11 @@           Core.fieldName = (Core.Name "operand"),           Core.fieldTerm = (Typed.unTypedTerm operand)}]})) +-- | DSL name token for hydra.haskell.syntax.ApplicationDeclarationHead+applicationDeclarationHeadApplicationDeclarationHead :: Typed.TypedName Syntax.ApplicationDeclarationHead+applicationDeclarationHeadApplicationDeclarationHead =+    Typed.TypedName (Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead")+ -- | DSL accessor for the function field of hydra.haskell.syntax.ApplicationDeclarationHead applicationDeclarationHeadFunction :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.DeclarationHead applicationDeclarationHeadFunction x =@@ -204,6 +213,10 @@           Core.fieldName = (Core.Name "argument"),           Core.fieldTerm = (Typed.unTypedTerm argument)}]})) +-- | DSL name token for hydra.haskell.syntax.ApplicationExpression+applicationExpressionApplicationExpression :: Typed.TypedName Syntax.ApplicationExpression+applicationExpressionApplicationExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.ApplicationExpression")+ -- | DSL accessor for the argument field of hydra.haskell.syntax.ApplicationExpression applicationExpressionArgument :: Typed.TypedTerm Syntax.ApplicationExpression -> Typed.TypedTerm Syntax.Expression applicationExpressionArgument x =@@ -269,6 +282,10 @@           Core.fieldName = (Core.Name "args"),           Core.fieldTerm = (Typed.unTypedTerm args)}]})) +-- | DSL name token for hydra.haskell.syntax.ApplicationPattern+applicationPatternApplicationPattern :: Typed.TypedName Syntax.ApplicationPattern+applicationPatternApplicationPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.ApplicationPattern")+ -- | DSL accessor for the args field of hydra.haskell.syntax.ApplicationPattern applicationPatternArgs :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm [Syntax.Pattern] applicationPatternArgs x =@@ -334,6 +351,10 @@           Core.fieldName = (Core.Name "argument"),           Core.fieldTerm = (Typed.unTypedTerm argument)}]})) +-- | DSL name token for hydra.haskell.syntax.ApplicationType+applicationTypeApplicationType :: Typed.TypedName Syntax.ApplicationType+applicationTypeApplicationType = Typed.TypedName (Core.Name "hydra.haskell.syntax.ApplicationType")+ -- | DSL accessor for the argument field of hydra.haskell.syntax.ApplicationType applicationTypeArgument :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type applicationTypeArgument x =@@ -399,6 +420,10 @@           Core.fieldName = (Core.Name "inner"),           Core.fieldTerm = (Typed.unTypedTerm inner)}]})) +-- | DSL name token for hydra.haskell.syntax.AsPattern+asPatternAsPattern :: Typed.TypedName Syntax.AsPattern+asPatternAsPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.AsPattern")+ -- | DSL accessor for the inner field of hydra.haskell.syntax.AsPattern asPatternInner :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.Pattern asPatternInner x =@@ -482,6 +507,10 @@         Core.projectionFieldName = (Core.Name "case")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.CaseExpression+caseExpressionCaseExpression :: Typed.TypedName Syntax.CaseExpression+caseExpressionCaseExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.CaseExpression")+ -- | DSL updater for the alternatives field of hydra.haskell.syntax.CaseExpression caseExpressionWithAlternatives :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm [Syntax.Alternative] -> Typed.TypedTerm Syntax.CaseExpression caseExpressionWithAlternatives original newVal =@@ -523,6 +552,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.CaseRhs"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.CaseRhs+caseRhsCaseRhs :: Typed.TypedName Syntax.CaseRhs+caseRhsCaseRhs = Typed.TypedName (Core.Name "hydra.haskell.syntax.CaseRhs")+ -- | DSL constructor for hydra.haskell.syntax.ClassConstraint classConstraint :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ClassConstraint classConstraint name types =@@ -536,6 +569,10 @@           Core.fieldName = (Core.Name "types"),           Core.fieldTerm = (Typed.unTypedTerm types)}]})) +-- | DSL name token for hydra.haskell.syntax.ClassConstraint+classConstraintClassConstraint :: Typed.TypedName Syntax.ClassConstraint+classConstraintClassConstraint = Typed.TypedName (Core.Name "hydra.haskell.syntax.ClassConstraint")+ -- | DSL accessor for the name field of hydra.haskell.syntax.ClassConstraint classConstraintName :: Typed.TypedTerm Syntax.ClassConstraint -> Typed.TypedTerm Syntax.Name classConstraintName x =@@ -601,6 +638,10 @@           Core.fieldName = (Core.Name "type"),           Core.fieldTerm = (Typed.unTypedTerm type_)}]})) +-- | DSL name token for hydra.haskell.syntax.ConstrainedType+constrainedTypeConstrainedType :: Typed.TypedName Syntax.ConstrainedType+constrainedTypeConstrainedType = Typed.TypedName (Core.Name "hydra.haskell.syntax.ConstrainedType")+ -- | DSL accessor for the ctx field of hydra.haskell.syntax.ConstrainedType constrainedTypeCtx :: Typed.TypedTerm Syntax.ConstrainedType -> Typed.TypedTerm Syntax.Constraint constrainedTypeCtx x =@@ -662,6 +703,10 @@         Core.fieldName = (Core.Name "class"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Constraint+constraintConstraint :: Typed.TypedName Syntax.Constraint+constraintConstraint = Typed.TypedName (Core.Name "hydra.haskell.syntax.Constraint")+ -- | DSL injection for the tuple variant of hydra.haskell.syntax.Constraint constraintTuple :: Typed.TypedTerm [Syntax.Constraint] -> Typed.TypedTerm Syntax.Constraint constraintTuple x =@@ -671,6 +716,10 @@         Core.fieldName = (Core.Name "tuple"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Constructor+constructorConstructor :: Typed.TypedName Syntax.Constructor+constructorConstructor = Typed.TypedName (Core.Name "hydra.haskell.syntax.Constructor")+ -- | DSL injection for the ordinary variant of hydra.haskell.syntax.Constructor constructorOrdinary :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm Syntax.Constructor constructorOrdinary x =@@ -741,6 +790,10 @@         Core.projectionFieldName = (Core.Name "context")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.DataDeclaration+dataDeclarationDataDeclaration :: Typed.TypedName Syntax.DataDeclaration+dataDeclarationDataDeclaration = Typed.TypedName (Core.Name "hydra.haskell.syntax.DataDeclaration")+ -- | DSL accessor for the deriving field of hydra.haskell.syntax.DataDeclaration dataDeclarationDeriving :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm [Syntax.DerivingClause] dataDeclarationDeriving x =@@ -1047,6 +1100,10 @@         Core.fieldName = (Core.Name "data"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.haskell.syntax.DataKeyword+dataKeywordDataKeyword :: Typed.TypedName Syntax.DataKeyword+dataKeywordDataKeyword = Typed.TypedName (Core.Name "hydra.haskell.syntax.DataKeyword")+ -- | DSL injection for the newtype variant of hydra.haskell.syntax.DataKeyword dataKeywordNewtype :: Typed.TypedTerm Syntax.DataKeyword dataKeywordNewtype =@@ -1065,6 +1122,10 @@         Core.fieldName = (Core.Name "data"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Declaration+declarationDeclaration :: Typed.TypedName Syntax.Declaration+declarationDeclaration = Typed.TypedName (Core.Name "hydra.haskell.syntax.Declaration")+ -- | DSL injection for the application variant of hydra.haskell.syntax.DeclarationHead declarationHeadApplication :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.DeclarationHead declarationHeadApplication x =@@ -1074,6 +1135,10 @@         Core.fieldName = (Core.Name "application"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.DeclarationHead+declarationHeadDeclarationHead :: Typed.TypedName Syntax.DeclarationHead+declarationHeadDeclarationHead = Typed.TypedName (Core.Name "hydra.haskell.syntax.DeclarationHead")+ -- | DSL injection for the simple variant of hydra.haskell.syntax.DeclarationHead declarationHeadSimple :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.DeclarationHead declarationHeadSimple x =@@ -1117,6 +1182,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.DerivingClause"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.DerivingClause+derivingClauseDerivingClause :: Typed.TypedName Syntax.DerivingClause+derivingClauseDerivingClause = Typed.TypedName (Core.Name "hydra.haskell.syntax.DerivingClause")+ -- | DSL injection for the declaration variant of hydra.haskell.syntax.Export exportDeclaration :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm Syntax.Export exportDeclaration x =@@ -1126,6 +1195,10 @@         Core.fieldName = (Core.Name "declaration"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Export+exportExport :: Typed.TypedName Syntax.Export+exportExport = Typed.TypedName (Core.Name "hydra.haskell.syntax.Export")+ -- | DSL injection for the module variant of hydra.haskell.syntax.Export exportModule :: Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.Export exportModule x =@@ -1171,6 +1244,10 @@         Core.fieldName = (Core.Name "do"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Expression+expressionExpression :: Typed.TypedName Syntax.Expression+expressionExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.Expression")+ -- | DSL injection for the if variant of hydra.haskell.syntax.Expression expressionIf :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression expressionIf x =@@ -1304,6 +1381,10 @@         Core.projectionFieldName = (Core.Name "comments")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.Field+fieldField :: Typed.TypedName Syntax.Field+fieldField = Typed.TypedName (Core.Name "hydra.haskell.syntax.Field")+ -- | DSL accessor for the name field of hydra.haskell.syntax.Field fieldName :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Name fieldName x =@@ -1335,6 +1416,10 @@           Core.fieldName = (Core.Name "value"),           Core.fieldTerm = (Typed.unTypedTerm value)}]})) +-- | DSL name token for hydra.haskell.syntax.FieldUpdate+fieldUpdateFieldUpdate :: Typed.TypedName Syntax.FieldUpdate+fieldUpdateFieldUpdate = Typed.TypedName (Core.Name "hydra.haskell.syntax.FieldUpdate")+ -- | DSL accessor for the name field of hydra.haskell.syntax.FieldUpdate fieldUpdateName :: Typed.TypedTerm Syntax.FieldUpdate -> Typed.TypedTerm Syntax.Name fieldUpdateName x =@@ -1490,6 +1575,10 @@         Core.projectionFieldName = (Core.Name "domain")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.FunctionType+functionTypeFunctionType :: Typed.TypedName Syntax.FunctionType+functionTypeFunctionType = Typed.TypedName (Core.Name "hydra.haskell.syntax.FunctionType")+ -- | DSL updater for the codomain field of hydra.haskell.syntax.FunctionType functionTypeWithCodomain :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType functionTypeWithCodomain original newVal =@@ -1558,6 +1647,10 @@         Core.projectionFieldName = (Core.Name "else")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.IfExpression+ifExpressionIfExpression :: Typed.TypedName Syntax.IfExpression+ifExpressionIfExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.IfExpression")+ -- | DSL accessor for the then field of hydra.haskell.syntax.IfExpression ifExpressionThen :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression ifExpressionThen x =@@ -1676,6 +1769,10 @@         Core.fieldName = (Core.Name "all"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.haskell.syntax.ImportExportSubspec+importExportSubspecImportExportSubspec :: Typed.TypedName Syntax.ImportExportSubspec+importExportSubspecImportExportSubspec = Typed.TypedName (Core.Name "hydra.haskell.syntax.ImportExportSubspec")+ -- | DSL injection for the list variant of hydra.haskell.syntax.ImportExportSubspec importExportSubspecList :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.ImportExportSubspec importExportSubspecList x =@@ -1685,6 +1782,14 @@         Core.fieldName = (Core.Name "list"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Import+importImport :: Typed.TypedName Syntax.Import+importImport = Typed.TypedName (Core.Name "hydra.haskell.syntax.Import")++-- | DSL name token for hydra.haskell.syntax.ImportModifier+importModifierImportModifier :: Typed.TypedName Syntax.ImportModifier+importModifierImportModifier = Typed.TypedName (Core.Name "hydra.haskell.syntax.ImportModifier")+ -- | DSL injection for the pattern variant of hydra.haskell.syntax.ImportModifier importModifierPattern :: Typed.TypedTerm Syntax.ImportModifier importModifierPattern =@@ -1739,6 +1844,10 @@         Core.fieldName = (Core.Name "hiding"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.ImportSpec+importSpecImportSpec :: Typed.TypedName Syntax.ImportSpec+importSpecImportSpec = Typed.TypedName (Core.Name "hydra.haskell.syntax.ImportSpec")+ -- | DSL injection for the list variant of hydra.haskell.syntax.ImportSpec importSpecList :: Typed.TypedTerm [Syntax.NamedImportExport] -> Typed.TypedTerm Syntax.ImportSpec importSpecList x =@@ -1888,6 +1997,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) +-- | DSL name token for hydra.haskell.syntax.InfixExpression+infixExpressionInfixExpression :: Typed.TypedName Syntax.InfixExpression+infixExpressionInfixExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.InfixExpression")+ -- | DSL accessor for the lhs field of hydra.haskell.syntax.InfixExpression infixExpressionLhs :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Expression infixExpressionLhs x =@@ -2003,6 +2116,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) +-- | DSL name token for hydra.haskell.syntax.InfixType+infixTypeInfixType :: Typed.TypedName Syntax.InfixType+infixTypeInfixType = Typed.TypedName (Core.Name "hydra.haskell.syntax.InfixType")+ -- | DSL accessor for the lhs field of hydra.haskell.syntax.InfixType infixTypeLhs :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Type infixTypeLhs x =@@ -2133,6 +2250,10 @@         Core.projectionFieldName = (Core.Name "inner")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.LambdaExpression+lambdaExpressionLambdaExpression :: Typed.TypedName Syntax.LambdaExpression+lambdaExpressionLambdaExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.LambdaExpression")+ -- | DSL updater for the bindings field of hydra.haskell.syntax.LambdaExpression lambdaExpressionWithBindings :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.LambdaExpression lambdaExpressionWithBindings original newVal =@@ -2198,6 +2319,10 @@         Core.projectionFieldName = (Core.Name "inner")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.LetExpression+letExpressionLetExpression :: Typed.TypedName Syntax.LetExpression+letExpressionLetExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.LetExpression")+ -- | DSL updater for the bindings field of hydra.haskell.syntax.LetExpression letExpressionWithBindings :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.LocalBinding] -> Typed.TypedTerm Syntax.LetExpression letExpressionWithBindings original newVal =@@ -2277,6 +2402,10 @@         Core.fieldName = (Core.Name "integer"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Literal+literalLiteral :: Typed.TypedName Syntax.Literal+literalLiteral = Typed.TypedName (Core.Name "hydra.haskell.syntax.Literal")+ -- | DSL injection for the string variant of hydra.haskell.syntax.Literal literalString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal literalString x =@@ -2286,6 +2415,10 @@         Core.fieldName = (Core.Name "string"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.LocalBinding+localBindingLocalBinding :: Typed.TypedName Syntax.LocalBinding+localBindingLocalBinding = Typed.TypedName (Core.Name "hydra.haskell.syntax.LocalBinding")+ -- | DSL injection for the signature variant of hydra.haskell.syntax.LocalBinding localBindingSignature :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.LocalBinding localBindingSignature x =@@ -2311,6 +2444,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.LocalBindings"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.LocalBindings+localBindingsLocalBindings :: Typed.TypedName Syntax.LocalBindings+localBindingsLocalBindings = Typed.TypedName (Core.Name "hydra.haskell.syntax.LocalBindings")+ -- | DSL constructor for hydra.haskell.syntax.Module module_ :: Typed.TypedTerm (Maybe Syntax.ModuleHead) -> Typed.TypedTerm [Syntax.Import] -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Module module_ head imports declarations =@@ -2379,6 +2516,10 @@         Core.projectionFieldName = (Core.Name "exports")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.ModuleHead+moduleHeadModuleHead :: Typed.TypedName Syntax.ModuleHead+moduleHeadModuleHead = Typed.TypedName (Core.Name "hydra.haskell.syntax.ModuleHead")+ -- | DSL accessor for the name field of hydra.haskell.syntax.ModuleHead moduleHeadName :: Typed.TypedTerm Syntax.ModuleHead -> Typed.TypedTerm Syntax.ModuleName moduleHeadName x =@@ -2469,6 +2610,10 @@         Core.projectionFieldName = (Core.Name "imports")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.Module+moduleModule :: Typed.TypedName Syntax.Module+moduleModule = Typed.TypedName (Core.Name "hydra.haskell.syntax.Module")+ -- | DSL constructor for the hydra.haskell.syntax.ModuleName wrapper moduleName :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ModuleName moduleName x =@@ -2476,6 +2621,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.ModuleName"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.ModuleName+moduleNameModuleName :: Typed.TypedName Syntax.ModuleName+moduleNameModuleName = Typed.TypedName (Core.Name "hydra.haskell.syntax.ModuleName")+ -- | DSL updater for the declarations field of hydra.haskell.syntax.Module moduleWithDeclarations :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Module moduleWithDeclarations original newVal =@@ -2557,6 +2706,10 @@         Core.fieldName = (Core.Name "implicit"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Name+nameName :: Typed.TypedName Syntax.Name+nameName = Typed.TypedName (Core.Name "hydra.haskell.syntax.Name")+ -- | DSL injection for the normal variant of hydra.haskell.syntax.Name nameNormal :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm Syntax.Name nameNormal x =@@ -2573,6 +2726,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.NamePart"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.NamePart+namePartNamePart :: Typed.TypedName Syntax.NamePart+namePartNamePart = Typed.TypedName (Core.Name "hydra.haskell.syntax.NamePart")+ -- | DSL constructor for hydra.haskell.syntax.NamedImportExport namedImportExport :: Typed.TypedTerm (Maybe Syntax.ImportModifier) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImportExportSubspec) -> Typed.TypedTerm Syntax.NamedImportExport namedImportExport modifier name subspec =@@ -2607,6 +2764,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.NamedImportExport+namedImportExportNamedImportExport :: Typed.TypedName Syntax.NamedImportExport+namedImportExportNamedImportExport = Typed.TypedName (Core.Name "hydra.haskell.syntax.NamedImportExport")+ -- | DSL accessor for the subspec field of hydra.haskell.syntax.NamedImportExport namedImportExportSubspec :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm (Maybe Syntax.ImportExportSubspec) namedImportExportSubspec x =@@ -2706,6 +2867,10 @@         Core.fieldName = (Core.Name "normal"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Operator+operatorOperator :: Typed.TypedName Syntax.Operator+operatorOperator = Typed.TypedName (Core.Name "hydra.haskell.syntax.Operator")+ -- | DSL injection for the application variant of hydra.haskell.syntax.Pattern patternApplication :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm Syntax.Pattern patternApplication x =@@ -2755,6 +2920,10 @@         Core.projectionFieldName = (Core.Name "pattern")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.PatternField+patternFieldPatternField :: Typed.TypedName Syntax.PatternField+patternFieldPatternField = Typed.TypedName (Core.Name "hydra.haskell.syntax.PatternField")+ -- | DSL updater for the name field of hydra.haskell.syntax.PatternField patternFieldWithName :: Typed.TypedTerm Syntax.PatternField -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PatternField patternFieldWithName original newVal =@@ -2816,6 +2985,10 @@         Core.fieldName = (Core.Name "name"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Pattern+patternPattern :: Typed.TypedName Syntax.Pattern+patternPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.Pattern")+ -- | DSL injection for the record variant of hydra.haskell.syntax.Pattern patternRecord :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm Syntax.Pattern patternRecord x =@@ -2895,6 +3068,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.PositionalConstructor+positionalConstructorPositionalConstructor :: Typed.TypedName Syntax.PositionalConstructor+positionalConstructorPositionalConstructor = Typed.TypedName (Core.Name "hydra.haskell.syntax.PositionalConstructor")+ -- | DSL updater for the comments field of hydra.haskell.syntax.PositionalConstructor positionalConstructorWithComments :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.PositionalConstructor positionalConstructorWithComments original newVal =@@ -2980,6 +3157,10 @@           Core.fieldName = (Core.Name "unqualified"),           Core.fieldTerm = (Typed.unTypedTerm unqualified)}]})) +-- | DSL name token for hydra.haskell.syntax.QualifiedName+qualifiedNameQualifiedName :: Typed.TypedName Syntax.QualifiedName+qualifiedNameQualifiedName = Typed.TypedName (Core.Name "hydra.haskell.syntax.QualifiedName")+ -- | DSL accessor for the qualifiers field of hydra.haskell.syntax.QualifiedName qualifiedNameQualifiers :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm [Syntax.NamePart] qualifiedNameQualifiers x =@@ -3075,6 +3256,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.RecordConstructor+recordConstructorRecordConstructor :: Typed.TypedName Syntax.RecordConstructor+recordConstructorRecordConstructor = Typed.TypedName (Core.Name "hydra.haskell.syntax.RecordConstructor")+ -- | DSL updater for the comments field of hydra.haskell.syntax.RecordConstructor recordConstructorWithComments :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.RecordConstructor recordConstructorWithComments original newVal =@@ -3178,6 +3363,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.RecordExpression+recordExpressionRecordExpression :: Typed.TypedName Syntax.RecordExpression+recordExpressionRecordExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.RecordExpression")+ -- | DSL updater for the fields field of hydra.haskell.syntax.RecordExpression recordExpressionWithFields :: Typed.TypedTerm Syntax.RecordExpression -> Typed.TypedTerm [Syntax.FieldUpdate] -> Typed.TypedTerm Syntax.RecordExpression recordExpressionWithFields original newVal =@@ -3243,6 +3432,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.RecordPattern+recordPatternRecordPattern :: Typed.TypedName Syntax.RecordPattern+recordPatternRecordPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.RecordPattern")+ -- | DSL updater for the fields field of hydra.haskell.syntax.RecordPattern recordPatternWithFields :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm [Syntax.PatternField] -> Typed.TypedTerm Syntax.RecordPattern recordPatternWithFields original newVal =@@ -3308,6 +3501,10 @@         Core.projectionFieldName = (Core.Name "inner")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.RecordUpdateExpression+recordUpdateExpressionRecordUpdateExpression :: Typed.TypedName Syntax.RecordUpdateExpression+recordUpdateExpressionRecordUpdateExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.RecordUpdateExpression")+ -- | DSL updater for the fields field of hydra.haskell.syntax.RecordUpdateExpression recordUpdateExpressionWithFields :: Typed.TypedTerm Syntax.RecordUpdateExpression -> Typed.TypedTerm [Syntax.FieldUpdate] -> Typed.TypedTerm Syntax.RecordUpdateExpression recordUpdateExpressionWithFields original newVal =@@ -3349,6 +3546,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.RightHandSide"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.RightHandSide+rightHandSideRightHandSide :: Typed.TypedName Syntax.RightHandSide+rightHandSideRightHandSide = Typed.TypedName (Core.Name "hydra.haskell.syntax.RightHandSide")+ -- | DSL constructor for hydra.haskell.syntax.SectionExpression sectionExpression :: Typed.TypedTerm Syntax.Operator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SectionExpression sectionExpression operator expression =@@ -3380,6 +3581,10 @@         Core.projectionFieldName = (Core.Name "operator")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.SectionExpression+sectionExpressionSectionExpression :: Typed.TypedName Syntax.SectionExpression+sectionExpressionSectionExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.SectionExpression")+ -- | DSL updater for the expression field of hydra.haskell.syntax.SectionExpression sectionExpressionWithExpression :: Typed.TypedTerm Syntax.SectionExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SectionExpression sectionExpressionWithExpression original newVal =@@ -3469,6 +3674,10 @@         Core.projectionFieldName = (Core.Name "rhs")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.SimpleValueBinding+simpleValueBindingSimpleValueBinding :: Typed.TypedName Syntax.SimpleValueBinding+simpleValueBindingSimpleValueBinding = Typed.TypedName (Core.Name "hydra.haskell.syntax.SimpleValueBinding")+ -- | DSL updater for the comments field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingWithComments :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.SimpleValueBinding simpleValueBindingWithComments original newVal =@@ -3600,6 +3809,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.Statement"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.Statement+statementStatement :: Typed.TypedName Syntax.Statement+statementStatement = Typed.TypedName (Core.Name "hydra.haskell.syntax.Statement")+ -- | DSL injection for the application variant of hydra.haskell.syntax.Type typeApplication :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type typeApplication x =@@ -3676,6 +3889,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.TypeSignature+typeSignatureTypeSignature :: Typed.TypedName Syntax.TypeSignature+typeSignatureTypeSignature = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypeSignature")+ -- | DSL updater for the name field of hydra.haskell.syntax.TypeSignature typeSignatureWithName :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TypeSignature typeSignatureWithName original newVal =@@ -3753,6 +3970,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.TypeSynonymDeclaration+typeSynonymDeclarationTypeSynonymDeclaration :: Typed.TypedName Syntax.TypeSynonymDeclaration+typeSynonymDeclarationTypeSynonymDeclaration = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypeSynonymDeclaration")+ -- | DSL updater for the comments field of hydra.haskell.syntax.TypeSynonymDeclaration typeSynonymDeclarationWithComments :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.TypeSynonymDeclaration typeSynonymDeclarationWithComments original newVal =@@ -3834,6 +4055,10 @@         Core.fieldName = (Core.Name "tuple"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.Type+typeType :: Typed.TypedName Syntax.Type+typeType = Typed.TypedName (Core.Name "hydra.haskell.syntax.Type")+ -- | DSL injection for the variable variant of hydra.haskell.syntax.Type typeVariable :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Type typeVariable x =@@ -3877,6 +4102,10 @@         Core.projectionFieldName = (Core.Name "typeSignature")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.TypedBinding+typedBindingTypedBinding :: Typed.TypedName Syntax.TypedBinding+typedBindingTypedBinding = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypedBinding")+ -- | DSL accessor for the valueBinding field of hydra.haskell.syntax.TypedBinding typedBindingValueBinding :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm Syntax.ValueBinding typedBindingValueBinding x =@@ -3989,6 +4218,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.TypedExpression+typedExpressionTypedExpression :: Typed.TypedName Syntax.TypedExpression+typedExpressionTypedExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypedExpression")+ -- | DSL updater for the inner field of hydra.haskell.syntax.TypedExpression typedExpressionWithInner :: Typed.TypedTerm Syntax.TypedExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypedExpression typedExpressionWithInner original newVal =@@ -4054,6 +4287,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.haskell.syntax.TypedPattern+typedPatternTypedPattern :: Typed.TypedName Syntax.TypedPattern+typedPatternTypedPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypedPattern")+ -- | DSL updater for the inner field of hydra.haskell.syntax.TypedPattern typedPatternWithInner :: Typed.TypedTerm Syntax.TypedPattern -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.TypedPattern typedPatternWithInner original newVal =@@ -4153,9 +4390,17 @@         Core.fieldName = (Core.Name "simple"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.haskell.syntax.ValueBinding+valueBindingValueBinding :: Typed.TypedName Syntax.ValueBinding+valueBindingValueBinding = Typed.TypedName (Core.Name "hydra.haskell.syntax.ValueBinding")+ -- | DSL constructor for the hydra.haskell.syntax.Variable wrapper variable :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Variable variable x =     Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.Variable"),       Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.haskell.syntax.Variable+variableVariable :: Typed.TypedName Syntax.Variable+variableVariable = Typed.TypedName (Core.Name "hydra.haskell.syntax.Variable")

@@ -102,9 +102,9 @@                   \namespace ->                     let raw = Packaging.unModuleName namespace                         parts = Strings.splitOn "." raw-                    in (Logic.ifElse (Logic.and (Equality.equal (Lists.length parts) 3) (Equality.equal (Lists.take 2 parts) [+                    in (Logic.ifElse (Logic.and (Logic.and (Equality.equal (Lists.length parts) 3) (Equality.equal (Lists.take 2 parts) [                       "hydra",-                      "lib"])) (Strings.cat2 "hydra.overlay.haskell.lib." (Strings.intercalate "." (Lists.drop 2 parts))) raw)+                      "lib"])) (Logic.not (Equality.equal raw "hydra.lib.defaults"))) (Strings.cat2 "hydra.overlay.haskell.lib." (Strings.intercalate "." (Lists.drop 2 parts))) raw)           createDeclarations =                   \def -> case def of                     Packaging.DefinitionType v0 ->@@ -620,6 +620,7 @@                     in (constantForFieldName name fname, (Core.unName fname))       in (Logic.ifElse useCoreImport (Lists.cons (toDecl (Core.Name "hydra.core.Name") nameDecl) (Lists.map (toDecl (Core.Name "hydra.core.Name")) fieldDecls)) []) +-- | Set the usesByteString flag in Haskell module metadata setMetaUsesByteString :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata setMetaUsesByteString b m =     Environment.HaskellModuleMetadata {@@ -628,6 +629,7 @@       Environment.haskellModuleMetadataUsesMap = (Environment.haskellModuleMetadataUsesMap m),       Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)} +-- | Set the usesInt flag in Haskell module metadata setMetaUsesInt :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata setMetaUsesInt b m =     Environment.HaskellModuleMetadata {@@ -636,6 +638,7 @@       Environment.haskellModuleMetadataUsesMap = (Environment.haskellModuleMetadataUsesMap m),       Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)} +-- | Set the usesMap flag in Haskell module metadata setMetaUsesMap :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata setMetaUsesMap b m =     Environment.HaskellModuleMetadata {@@ -644,6 +647,7 @@       Environment.haskellModuleMetadataUsesMap = b,       Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)} +-- | Set the usesSet flag in Haskell module metadata setMetaUsesSet :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata setMetaUsesSet b m =     Environment.HaskellModuleMetadata {

@@ -27,20 +27,104 @@  _Alternative_binds = Core.Name "binds" --- | A type constraint-data Constraint =-  -- | A class constraint-  ConstraintClass ClassConstraint |-  -- | A tuple of constraints-  ConstraintTuple [Constraint]+-- | An application-style declaration head+data ApplicationDeclarationHead =+  ApplicationDeclarationHead {+    -- | The function being applied+    applicationDeclarationHeadFunction :: DeclarationHead,+    -- | The type variable operand+    applicationDeclarationHeadOperand :: Variable}   deriving (Eq, Ord, Read, Show) -_Constraint = Core.Name "hydra.haskell.syntax.Constraint"+_ApplicationDeclarationHead = Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead" -_Constraint_class = Core.Name "class"+_ApplicationDeclarationHead_function = Core.Name "function" -_Constraint_tuple = Core.Name "tuple"+_ApplicationDeclarationHead_operand = Core.Name "operand" +-- | An application expression+data ApplicationExpression =+  ApplicationExpression {+    -- | The function being applied+    applicationExpressionFunction :: Expression,+    -- | The argument+    applicationExpressionArgument :: Expression}+  deriving (Eq, Ord, Read, Show)++_ApplicationExpression = Core.Name "hydra.haskell.syntax.ApplicationExpression"++_ApplicationExpression_function = Core.Name "function"++_ApplicationExpression_argument = Core.Name "argument"++-- | An application pattern+data ApplicationPattern =+  ApplicationPattern {+    -- | The constructor name+    applicationPatternName :: Name,+    -- | The pattern arguments+    applicationPatternArgs :: [Pattern]}+  deriving (Eq, Ord, Read, Show)++_ApplicationPattern = Core.Name "hydra.haskell.syntax.ApplicationPattern"++_ApplicationPattern_name = Core.Name "name"++_ApplicationPattern_args = Core.Name "args"++-- | An application type+data ApplicationType =+  ApplicationType {+    -- | The type being applied+    applicationTypeContext :: Type,+    -- | The type argument+    applicationTypeArgument :: Type}+  deriving (Eq, Ord, Read, Show)++_ApplicationType = Core.Name "hydra.haskell.syntax.ApplicationType"++_ApplicationType_context = Core.Name "context"++_ApplicationType_argument = Core.Name "argument"++-- | An 'as' pattern+data AsPattern =+  AsPattern {+    -- | The bound name+    asPatternName :: Name,+    -- | The inner pattern+    asPatternInner :: Pattern}+  deriving (Eq, Ord, Read, Show)++_AsPattern = Core.Name "hydra.haskell.syntax.AsPattern"++_AsPattern_name = Core.Name "name"++_AsPattern_inner = Core.Name "inner"++-- | A case expression+data CaseExpression =+  CaseExpression {+    -- | The expression being matched+    caseExpressionCase :: Expression,+    -- | The pattern-matching alternatives+    caseExpressionAlternatives :: [Alternative]}+  deriving (Eq, Ord, Read, Show)++_CaseExpression = Core.Name "hydra.haskell.syntax.CaseExpression"++_CaseExpression_case = Core.Name "case"++_CaseExpression_alternatives = Core.Name "alternatives"++-- | The right-hand side of a pattern-matching alternative+newtype CaseRhs =+  CaseRhs {+    unCaseRhs :: Expression}+  deriving (Eq, Ord, Read, Show)++_CaseRhs = Core.Name "hydra.haskell.syntax.CaseRhs"+ -- | A class constraint data ClassConstraint =   ClassConstraint {@@ -56,14 +140,35 @@  _ClassConstraint_types = Core.Name "types" --- | The right-hand side of a pattern-matching alternative-newtype CaseRhs =-  CaseRhs {-    unCaseRhs :: Expression}+-- | A type with a context (type class constraints)+data ConstrainedType =+  ConstrainedType {+    -- | The type class context+    constrainedTypeCtx :: Constraint,+    -- | The constrained type+    constrainedTypeType :: Type}   deriving (Eq, Ord, Read, Show) -_CaseRhs = Core.Name "hydra.haskell.syntax.CaseRhs"+_ConstrainedType = Core.Name "hydra.haskell.syntax.ConstrainedType" +_ConstrainedType_ctx = Core.Name "ctx"++_ConstrainedType_type = Core.Name "type"++-- | A type constraint+data Constraint =+  -- | A class constraint+  ConstraintClass ClassConstraint |+  -- | A tuple of constraints+  ConstraintTuple [Constraint]+  deriving (Eq, Ord, Read, Show)++_Constraint = Core.Name "hydra.haskell.syntax.Constraint"++_Constraint_class = Core.Name "class"++_Constraint_tuple = Core.Name "tuple"+ -- | A data constructor data Constructor =   -- | An ordinary (positional) constructor@@ -78,44 +183,6 @@  _Constructor_record = Core.Name "record" --- | An ordinary (positional) data constructor-data PositionalConstructor =-  PositionalConstructor {-    -- | The name of the constructor-    positionalConstructorName :: Name,-    -- | The types of the positional fields-    positionalConstructorFields :: [Type],-    -- | Optional comments-    positionalConstructorComments :: (Maybe String)}-  deriving (Eq, Ord, Read, Show)--_PositionalConstructor = Core.Name "hydra.haskell.syntax.PositionalConstructor"--_PositionalConstructor_name = Core.Name "name"--_PositionalConstructor_fields = Core.Name "fields"--_PositionalConstructor_comments = Core.Name "comments"---- | A record-style data constructor-data RecordConstructor =-  RecordConstructor {-    -- | The name of the constructor-    recordConstructorName :: Name,-    -- | The named fields of the record-    recordConstructorFields :: [Field],-    -- | Optional comments-    recordConstructorComments :: (Maybe String)}-  deriving (Eq, Ord, Read, Show)--_RecordConstructor = Core.Name "hydra.haskell.syntax.RecordConstructor"--_RecordConstructor_name = Core.Name "name"--_RecordConstructor_fields = Core.Name "fields"--_RecordConstructor_comments = Core.Name "comments"- -- | A data type declaration data DataDeclaration =   DataDeclaration {@@ -195,21 +262,6 @@  _DeclarationHead_simple = Core.Name "simple" --- | An application-style declaration head-data ApplicationDeclarationHead =-  ApplicationDeclarationHead {-    -- | The function being applied-    applicationDeclarationHeadFunction :: DeclarationHead,-    -- | The type variable operand-    applicationDeclarationHeadOperand :: Variable}-  deriving (Eq, Ord, Read, Show)--_ApplicationDeclarationHead = Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead"--_ApplicationDeclarationHead_function = Core.Name "function"--_ApplicationDeclarationHead_operand = Core.Name "operand"- -- | A 'deriving' clause newtype DerivingClause =   DerivingClause {@@ -302,164 +354,6 @@  _Expression_variable = Core.Name "variable" --- | An application expression-data ApplicationExpression =-  ApplicationExpression {-    -- | The function being applied-    applicationExpressionFunction :: Expression,-    -- | The argument-    applicationExpressionArgument :: Expression}-  deriving (Eq, Ord, Read, Show)--_ApplicationExpression = Core.Name "hydra.haskell.syntax.ApplicationExpression"--_ApplicationExpression_function = Core.Name "function"--_ApplicationExpression_argument = Core.Name "argument"---- | A case expression-data CaseExpression =-  CaseExpression {-    -- | The expression being matched-    caseExpressionCase :: Expression,-    -- | The pattern-matching alternatives-    caseExpressionAlternatives :: [Alternative]}-  deriving (Eq, Ord, Read, Show)--_CaseExpression = Core.Name "hydra.haskell.syntax.CaseExpression"--_CaseExpression_case = Core.Name "case"--_CaseExpression_alternatives = Core.Name "alternatives"---- | A record constructor expression-data RecordExpression =-  RecordExpression {-    -- | The constructor name-    recordExpressionName :: Name,-    -- | The field assignments-    recordExpressionFields :: [FieldUpdate]}-  deriving (Eq, Ord, Read, Show)--_RecordExpression = Core.Name "hydra.haskell.syntax.RecordExpression"--_RecordExpression_name = Core.Name "name"--_RecordExpression_fields = Core.Name "fields"---- | An 'if' expression-data IfExpression =-  IfExpression {-    -- | The condition expression-    ifExpressionCondition :: Expression,-    -- | The 'then' branch-    ifExpressionThen :: Expression,-    -- | The 'else' branch-    ifExpressionElse :: Expression}-  deriving (Eq, Ord, Read, Show)--_IfExpression = Core.Name "hydra.haskell.syntax.IfExpression"--_IfExpression_condition = Core.Name "condition"--_IfExpression_then = Core.Name "then"--_IfExpression_else = Core.Name "else"---- | An infix application expression-data InfixExpression =-  InfixExpression {-    -- | The left-hand operand-    infixExpressionLhs :: Expression,-    -- | The infix operator-    infixExpressionOperator :: Operator,-    -- | The right-hand operand-    infixExpressionRhs :: Expression}-  deriving (Eq, Ord, Read, Show)--_InfixExpression = Core.Name "hydra.haskell.syntax.InfixExpression"--_InfixExpression_lhs = Core.Name "lhs"--_InfixExpression_operator = Core.Name "operator"--_InfixExpression_rhs = Core.Name "rhs"---- | A lambda expression-data LambdaExpression =-  LambdaExpression {-    -- | The patterns binding parameters-    lambdaExpressionBindings :: [Pattern],-    -- | The body of the lambda-    lambdaExpressionInner :: Expression}-  deriving (Eq, Ord, Read, Show)--_LambdaExpression = Core.Name "hydra.haskell.syntax.LambdaExpression"--_LambdaExpression_bindings = Core.Name "bindings"--_LambdaExpression_inner = Core.Name "inner"---- | A 'let' expression-data LetExpression =-  LetExpression {-    -- | The local bindings-    letExpressionBindings :: [LocalBinding],-    -- | The body of the let expression-    letExpressionInner :: Expression}-  deriving (Eq, Ord, Read, Show)--_LetExpression = Core.Name "hydra.haskell.syntax.LetExpression"--_LetExpression_bindings = Core.Name "bindings"--_LetExpression_inner = Core.Name "inner"---- | A section expression-data SectionExpression =-  SectionExpression {-    -- | The operator-    sectionExpressionOperator :: Operator,-    -- | The operand-    sectionExpressionExpression :: Expression}-  deriving (Eq, Ord, Read, Show)--_SectionExpression = Core.Name "hydra.haskell.syntax.SectionExpression"--_SectionExpression_operator = Core.Name "operator"--_SectionExpression_expression = Core.Name "expression"---- | A type signature expression-data TypedExpression =-  TypedExpression {-    -- | The expression being typed-    typedExpressionInner :: Expression,-    -- | The type signature-    typedExpressionType :: Type}-  deriving (Eq, Ord, Read, Show)--_TypedExpression = Core.Name "hydra.haskell.syntax.TypedExpression"--_TypedExpression_inner = Core.Name "inner"--_TypedExpression_type = Core.Name "type"---- | An update record expression-data RecordUpdateExpression =-  RecordUpdateExpression {-    -- | The record being updated-    recordUpdateExpressionInner :: Expression,-    -- | The field updates-    recordUpdateExpressionFields :: [FieldUpdate]}-  deriving (Eq, Ord, Read, Show)--_RecordUpdateExpression = Core.Name "hydra.haskell.syntax.RecordUpdateExpression"--_RecordUpdateExpression_inner = Core.Name "inner"--_RecordUpdateExpression_fields = Core.Name "fields"- -- | A field (name/type pair) data Field =   Field {@@ -494,6 +388,40 @@  _FieldUpdate_value = Core.Name "value" +-- | A function type+data FunctionType =+  FunctionType {+    -- | The domain type+    functionTypeDomain :: Type,+    -- | The codomain type+    functionTypeCodomain :: Type}+  deriving (Eq, Ord, Read, Show)++_FunctionType = Core.Name "hydra.haskell.syntax.FunctionType"++_FunctionType_domain = Core.Name "domain"++_FunctionType_codomain = Core.Name "codomain"++-- | An 'if' expression+data IfExpression =+  IfExpression {+    -- | The condition expression+    ifExpressionCondition :: Expression,+    -- | The 'then' branch+    ifExpressionThen :: Expression,+    -- | The 'else' branch+    ifExpressionElse :: Expression}+  deriving (Eq, Ord, Read, Show)++_IfExpression = Core.Name "hydra.haskell.syntax.IfExpression"++_IfExpression_condition = Core.Name "condition"++_IfExpression_then = Core.Name "then"++_IfExpression_else = Core.Name "else"+ -- | An import statement data Import =   Import {@@ -517,6 +445,32 @@  _Import_spec = Core.Name "spec" +-- | A subspecification within an import/export+data ImportExportSubspec =+  -- | Import/export all+  ImportExportSubspecAll |+  -- | Import/export specific names+  ImportExportSubspecList [Name]+  deriving (Eq, Ord, Read, Show)++_ImportExportSubspec = Core.Name "hydra.haskell.syntax.ImportExportSubspec"++_ImportExportSubspec_all = Core.Name "all"++_ImportExportSubspec_list = Core.Name "list"++-- | An import modifier ('pattern' or 'type')+data ImportModifier =+  ImportModifierPattern |+  ImportModifierType+  deriving (Eq, Ord, Read, Show)++_ImportModifier = Core.Name "hydra.haskell.syntax.ImportModifier"++_ImportModifier_pattern = Core.Name "pattern"++_ImportModifier_type = Core.Name "type"+ -- | An import specification data ImportSpec =   -- | A list of imports to include@@ -531,51 +485,74 @@  _ImportSpec_hiding = Core.Name "hiding" --- | An import modifier ('pattern' or 'type')-data ImportModifier =-  ImportModifierPattern |-  ImportModifierType+-- | An infix application expression+data InfixExpression =+  InfixExpression {+    -- | The left-hand operand+    infixExpressionLhs :: Expression,+    -- | The infix operator+    infixExpressionOperator :: Operator,+    -- | The right-hand operand+    infixExpressionRhs :: Expression}   deriving (Eq, Ord, Read, Show) -_ImportModifier = Core.Name "hydra.haskell.syntax.ImportModifier"+_InfixExpression = Core.Name "hydra.haskell.syntax.InfixExpression" -_ImportModifier_pattern = Core.Name "pattern"+_InfixExpression_lhs = Core.Name "lhs" -_ImportModifier_type = Core.Name "type"+_InfixExpression_operator = Core.Name "operator" --- | An import or export specification-data NamedImportExport =-  NamedImportExport {-    -- | Optional import modifier-    namedImportExportModifier :: (Maybe ImportModifier),-    -- | The name being imported or exported-    namedImportExportName :: Name,-    -- | Optional subspecification-    namedImportExportSubspec :: (Maybe ImportExportSubspec)}+_InfixExpression_rhs = Core.Name "rhs"++-- | An infix type application+data InfixType =+  InfixType {+    -- | The left-hand type+    infixTypeLhs :: Type,+    -- | The type operator+    infixTypeOperator :: Operator,+    -- | The right-hand type+    infixTypeRhs :: Type}   deriving (Eq, Ord, Read, Show) -_NamedImportExport = Core.Name "hydra.haskell.syntax.NamedImportExport"+_InfixType = Core.Name "hydra.haskell.syntax.InfixType" -_NamedImportExport_modifier = Core.Name "modifier"+_InfixType_lhs = Core.Name "lhs" -_NamedImportExport_name = Core.Name "name"+_InfixType_operator = Core.Name "operator" -_NamedImportExport_subspec = Core.Name "subspec"+_InfixType_rhs = Core.Name "rhs" --- | A subspecification within an import/export-data ImportExportSubspec =-  -- | Import/export all-  ImportExportSubspecAll |-  -- | Import/export specific names-  ImportExportSubspecList [Name]+-- | A lambda expression+data LambdaExpression =+  LambdaExpression {+    -- | The patterns binding parameters+    lambdaExpressionBindings :: [Pattern],+    -- | The body of the lambda+    lambdaExpressionInner :: Expression}   deriving (Eq, Ord, Read, Show) -_ImportExportSubspec = Core.Name "hydra.haskell.syntax.ImportExportSubspec"+_LambdaExpression = Core.Name "hydra.haskell.syntax.LambdaExpression" -_ImportExportSubspec_all = Core.Name "all"+_LambdaExpression_bindings = Core.Name "bindings" -_ImportExportSubspec_list = Core.Name "list"+_LambdaExpression_inner = Core.Name "inner" +-- | A 'let' expression+data LetExpression =+  LetExpression {+    -- | The local bindings+    letExpressionBindings :: [LocalBinding],+    -- | The body of the let expression+    letExpressionInner :: Expression}+  deriving (Eq, Ord, Read, Show)++_LetExpression = Core.Name "hydra.haskell.syntax.LetExpression"++_LetExpression_bindings = Core.Name "bindings"++_LetExpression_inner = Core.Name "inner"+ -- | A literal value data Literal =   -- | A character literal@@ -696,6 +673,25 @@  _NamePart = Core.Name "hydra.haskell.syntax.NamePart" +-- | An import or export specification+data NamedImportExport =+  NamedImportExport {+    -- | Optional import modifier+    namedImportExportModifier :: (Maybe ImportModifier),+    -- | The name being imported or exported+    namedImportExportName :: Name,+    -- | Optional subspecification+    namedImportExportSubspec :: (Maybe ImportExportSubspec)}+  deriving (Eq, Ord, Read, Show)++_NamedImportExport = Core.Name "hydra.haskell.syntax.NamedImportExport"++_NamedImportExport_modifier = Core.Name "modifier"++_NamedImportExport_name = Core.Name "name"++_NamedImportExport_subspec = Core.Name "subspec"+ -- | An operator data Operator =   -- | A function used as an infix operator@@ -752,36 +748,89 @@  _Pattern_wildcard = Core.Name "wildcard" --- | An application pattern-data ApplicationPattern =-  ApplicationPattern {-    -- | The constructor name-    applicationPatternName :: Name,-    -- | The pattern arguments-    applicationPatternArgs :: [Pattern]}+-- | A pattern field+data PatternField =+  PatternField {+    -- | The field name+    patternFieldName :: Name,+    -- | The field pattern+    patternFieldPattern :: Pattern}   deriving (Eq, Ord, Read, Show) -_ApplicationPattern = Core.Name "hydra.haskell.syntax.ApplicationPattern"+_PatternField = Core.Name "hydra.haskell.syntax.PatternField" -_ApplicationPattern_name = Core.Name "name"+_PatternField_name = Core.Name "name" -_ApplicationPattern_args = Core.Name "args"+_PatternField_pattern = Core.Name "pattern" --- | An 'as' pattern-data AsPattern =-  AsPattern {-    -- | The bound name-    asPatternName :: Name,-    -- | The inner pattern-    asPatternInner :: Pattern}+-- | An ordinary (positional) data constructor+data PositionalConstructor =+  PositionalConstructor {+    -- | The name of the constructor+    positionalConstructorName :: Name,+    -- | The types of the positional fields+    positionalConstructorFields :: [Type],+    -- | Optional comments+    positionalConstructorComments :: (Maybe String)}   deriving (Eq, Ord, Read, Show) -_AsPattern = Core.Name "hydra.haskell.syntax.AsPattern"+_PositionalConstructor = Core.Name "hydra.haskell.syntax.PositionalConstructor" -_AsPattern_name = Core.Name "name"+_PositionalConstructor_name = Core.Name "name" -_AsPattern_inner = Core.Name "inner"+_PositionalConstructor_fields = Core.Name "fields" +_PositionalConstructor_comments = Core.Name "comments"++-- | A qualified name+data QualifiedName =+  QualifiedName {+    -- | The qualifier parts+    qualifiedNameQualifiers :: [NamePart],+    -- | The unqualified name part+    qualifiedNameUnqualified :: NamePart}+  deriving (Eq, Ord, Read, Show)++_QualifiedName = Core.Name "hydra.haskell.syntax.QualifiedName"++_QualifiedName_qualifiers = Core.Name "qualifiers"++_QualifiedName_unqualified = Core.Name "unqualified"++-- | A record-style data constructor+data RecordConstructor =+  RecordConstructor {+    -- | The name of the constructor+    recordConstructorName :: Name,+    -- | The named fields of the record+    recordConstructorFields :: [Field],+    -- | Optional comments+    recordConstructorComments :: (Maybe String)}+  deriving (Eq, Ord, Read, Show)++_RecordConstructor = Core.Name "hydra.haskell.syntax.RecordConstructor"++_RecordConstructor_name = Core.Name "name"++_RecordConstructor_fields = Core.Name "fields"++_RecordConstructor_comments = Core.Name "comments"++-- | A record constructor expression+data RecordExpression =+  RecordExpression {+    -- | The constructor name+    recordExpressionName :: Name,+    -- | The field assignments+    recordExpressionFields :: [FieldUpdate]}+  deriving (Eq, Ord, Read, Show)++_RecordExpression = Core.Name "hydra.haskell.syntax.RecordExpression"++_RecordExpression_name = Core.Name "name"++_RecordExpression_fields = Core.Name "fields"+ -- | A record pattern data RecordPattern =   RecordPattern {@@ -797,58 +846,66 @@  _RecordPattern_fields = Core.Name "fields" --- | A typed pattern-data TypedPattern =-  TypedPattern {-    -- | The inner pattern-    typedPatternInner :: Pattern,-    -- | The type annotation-    typedPatternType :: Type}+-- | An update record expression+data RecordUpdateExpression =+  RecordUpdateExpression {+    -- | The record being updated+    recordUpdateExpressionInner :: Expression,+    -- | The field updates+    recordUpdateExpressionFields :: [FieldUpdate]}   deriving (Eq, Ord, Read, Show) -_TypedPattern = Core.Name "hydra.haskell.syntax.TypedPattern"+_RecordUpdateExpression = Core.Name "hydra.haskell.syntax.RecordUpdateExpression" -_TypedPattern_inner = Core.Name "inner"+_RecordUpdateExpression_inner = Core.Name "inner" -_TypedPattern_type = Core.Name "type"+_RecordUpdateExpression_fields = Core.Name "fields" --- | A pattern field-data PatternField =-  PatternField {-    -- | The field name-    patternFieldName :: Name,-    -- | The field pattern-    patternFieldPattern :: Pattern}+-- | A right-hand side of a binding+newtype RightHandSide =+  RightHandSide {+    unRightHandSide :: Expression}   deriving (Eq, Ord, Read, Show) -_PatternField = Core.Name "hydra.haskell.syntax.PatternField"+_RightHandSide = Core.Name "hydra.haskell.syntax.RightHandSide" -_PatternField_name = Core.Name "name"+-- | A section expression+data SectionExpression =+  SectionExpression {+    -- | The operator+    sectionExpressionOperator :: Operator,+    -- | The operand+    sectionExpressionExpression :: Expression}+  deriving (Eq, Ord, Read, Show) -_PatternField_pattern = Core.Name "pattern"+_SectionExpression = Core.Name "hydra.haskell.syntax.SectionExpression" --- | A qualified name-data QualifiedName =-  QualifiedName {-    -- | The qualifier parts-    qualifiedNameQualifiers :: [NamePart],-    -- | The unqualified name part-    qualifiedNameUnqualified :: NamePart}+_SectionExpression_operator = Core.Name "operator"++_SectionExpression_expression = Core.Name "expression"++-- | A simple value binding+data SimpleValueBinding =+  SimpleValueBinding {+    -- | The pattern being bound+    simpleValueBindingPattern :: Pattern,+    -- | The right-hand side+    simpleValueBindingRhs :: RightHandSide,+    -- | Optional local bindings (where clause)+    simpleValueBindingLocalBindings :: (Maybe LocalBindings),+    -- | Optional comments+    simpleValueBindingComments :: (Maybe String)}   deriving (Eq, Ord, Read, Show) -_QualifiedName = Core.Name "hydra.haskell.syntax.QualifiedName"+_SimpleValueBinding = Core.Name "hydra.haskell.syntax.SimpleValueBinding" -_QualifiedName_qualifiers = Core.Name "qualifiers"+_SimpleValueBinding_pattern = Core.Name "pattern" -_QualifiedName_unqualified = Core.Name "unqualified"+_SimpleValueBinding_rhs = Core.Name "rhs" --- | A right-hand side of a binding-newtype RightHandSide =-  RightHandSide {-    unRightHandSide :: Expression}-  deriving (Eq, Ord, Read, Show)+_SimpleValueBinding_localBindings = Core.Name "localBindings" -_RightHandSide = Core.Name "hydra.haskell.syntax.RightHandSide"+_SimpleValueBinding_comments = Core.Name "comments"  -- | A do-notation statement newtype Statement =@@ -892,69 +949,20 @@  _Type_variable = Core.Name "variable" --- | An application type-data ApplicationType =-  ApplicationType {-    -- | The type being applied-    applicationTypeContext :: Type,-    -- | The type argument-    applicationTypeArgument :: Type}-  deriving (Eq, Ord, Read, Show)--_ApplicationType = Core.Name "hydra.haskell.syntax.ApplicationType"--_ApplicationType_context = Core.Name "context"--_ApplicationType_argument = Core.Name "argument"---- | A type with a context (type class constraints)-data ConstrainedType =-  ConstrainedType {-    -- | The type class context-    constrainedTypeCtx :: Constraint,-    -- | The constrained type-    constrainedTypeType :: Type}-  deriving (Eq, Ord, Read, Show)--_ConstrainedType = Core.Name "hydra.haskell.syntax.ConstrainedType"--_ConstrainedType_ctx = Core.Name "ctx"--_ConstrainedType_type = Core.Name "type"---- | A function type-data FunctionType =-  FunctionType {-    -- | The domain type-    functionTypeDomain :: Type,-    -- | The codomain type-    functionTypeCodomain :: Type}-  deriving (Eq, Ord, Read, Show)--_FunctionType = Core.Name "hydra.haskell.syntax.FunctionType"--_FunctionType_domain = Core.Name "domain"--_FunctionType_codomain = Core.Name "codomain"---- | An infix type application-data InfixType =-  InfixType {-    -- | The left-hand type-    infixTypeLhs :: Type,-    -- | The type operator-    infixTypeOperator :: Operator,-    -- | The right-hand type-    infixTypeRhs :: Type}+-- | A type signature+data TypeSignature =+  TypeSignature {+    -- | The name being typed+    typeSignatureName :: Name,+    -- | The type+    typeSignatureType :: Type}   deriving (Eq, Ord, Read, Show) -_InfixType = Core.Name "hydra.haskell.syntax.InfixType"--_InfixType_lhs = Core.Name "lhs"+_TypeSignature = Core.Name "hydra.haskell.syntax.TypeSignature" -_InfixType_operator = Core.Name "operator"+_TypeSignature_name = Core.Name "name" -_InfixType_rhs = Core.Name "rhs"+_TypeSignature_type = Core.Name "type"  -- | A type synonym declaration data TypeSynonymDeclaration =@@ -975,21 +983,6 @@  _TypeSynonymDeclaration_comments = Core.Name "comments" --- | A type signature-data TypeSignature =-  TypeSignature {-    -- | The name being typed-    typeSignatureName :: Name,-    -- | The type-    typeSignatureType :: Type}-  deriving (Eq, Ord, Read, Show)--_TypeSignature = Core.Name "hydra.haskell.syntax.TypeSignature"--_TypeSignature_name = Core.Name "name"--_TypeSignature_type = Core.Name "type"- -- | A binding with its type signature data TypedBinding =   TypedBinding {@@ -1009,38 +1002,45 @@  _TypedBinding_comments = Core.Name "comments" --- | A value binding-data ValueBinding =-  -- | A simple value binding-  ValueBindingSimple SimpleValueBinding+-- | A type signature expression+data TypedExpression =+  TypedExpression {+    -- | The expression being typed+    typedExpressionInner :: Expression,+    -- | The type signature+    typedExpressionType :: Type}   deriving (Eq, Ord, Read, Show) -_ValueBinding = Core.Name "hydra.haskell.syntax.ValueBinding"+_TypedExpression = Core.Name "hydra.haskell.syntax.TypedExpression" -_ValueBinding_simple = Core.Name "simple"+_TypedExpression_inner = Core.Name "inner" --- | A simple value binding-data SimpleValueBinding =-  SimpleValueBinding {-    -- | The pattern being bound-    simpleValueBindingPattern :: Pattern,-    -- | The right-hand side-    simpleValueBindingRhs :: RightHandSide,-    -- | Optional local bindings (where clause)-    simpleValueBindingLocalBindings :: (Maybe LocalBindings),-    -- | Optional comments-    simpleValueBindingComments :: (Maybe String)}+_TypedExpression_type = Core.Name "type"++-- | A typed pattern+data TypedPattern =+  TypedPattern {+    -- | The inner pattern+    typedPatternInner :: Pattern,+    -- | The type annotation+    typedPatternType :: Type}   deriving (Eq, Ord, Read, Show) -_SimpleValueBinding = Core.Name "hydra.haskell.syntax.SimpleValueBinding"+_TypedPattern = Core.Name "hydra.haskell.syntax.TypedPattern" -_SimpleValueBinding_pattern = Core.Name "pattern"+_TypedPattern_inner = Core.Name "inner" -_SimpleValueBinding_rhs = Core.Name "rhs"+_TypedPattern_type = Core.Name "type" -_SimpleValueBinding_localBindings = Core.Name "localBindings"+-- | A value binding+data ValueBinding =+  -- | A simple value binding+  ValueBindingSimple SimpleValueBinding+  deriving (Eq, Ord, Read, Show) -_SimpleValueBinding_comments = Core.Name "comments"+_ValueBinding = Core.Name "hydra.haskell.syntax.ValueBinding"++_ValueBinding_simple = Core.Name "simple"  -- | A type variable newtype Variable =