hydra-lisp 0.17.0 → 0.17.1

raw patch · 6 files changed

+422/−15 lines, 6 filesdep ~hydra-kernelPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: hydra-kernel

API changes (from Hackage documentation)

Files

• CHANGELOG.md +139/−0
• hydra-lisp.cabal +3/−3
• src/main/haskell/Hydra/Dsl/Lisp/Syntax.hs +266/−7
• src/main/haskell/Hydra/Lisp/Coder.hs +6/−0
• src/main/haskell/Hydra/Lisp/Serde.hs +7/−2
• src/main/haskell/Hydra/Lisp/Syntax.hs +1/−3

@@ -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

@@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.39.1.+-- This file has been generated from package.yaml by hpack version 0.38.1. -- -- see: https://github.com/sol/hpack  name:           hydra-lisp-version:        0.17.0+version:        0.17.1 synopsis:       Hydra's Lisp coder: emit Clojure/Scheme/Common-Lisp/Emacs-Lisp source 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". Lisp support for Hydra (shared across Clojure, Scheme, Common Lisp, and Emacs Lisp) category:       Data@@ -39,6 +39,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

@@ -21,6 +21,10 @@           Core.fieldName = (Core.Name "expressions"),           Core.fieldTerm = (Typed.unTypedTerm expressions)}]})) +-- | DSL name token for hydra.lisp.syntax.AndExpression+andExpressionAndExpression :: Typed.TypedName Syntax.AndExpression+andExpressionAndExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.AndExpression")+ -- | DSL accessor for the expressions field of hydra.lisp.syntax.AndExpression andExpressionExpressions :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm [Syntax.Expression] andExpressionExpressions x =@@ -53,6 +57,10 @@           Core.fieldName = (Core.Name "arguments"),           Core.fieldTerm = (Typed.unTypedTerm arguments)}]})) +-- | DSL name token for hydra.lisp.syntax.Application+applicationApplication :: Typed.TypedName Syntax.Application+applicationApplication = Typed.TypedName (Core.Name "hydra.lisp.syntax.Application")+ -- | DSL accessor for the arguments field of hydra.lisp.syntax.Application applicationArguments :: Typed.TypedTerm Syntax.Application -> Typed.TypedTerm [Syntax.Expression] applicationArguments x =@@ -115,6 +123,10 @@           Core.fieldName = (Core.Name "expressions"),           Core.fieldTerm = (Typed.unTypedTerm expressions)}]})) +-- | DSL name token for hydra.lisp.syntax.BeginExpression+beginExpressionBeginExpression :: Typed.TypedName Syntax.BeginExpression+beginExpressionBeginExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.BeginExpression")+ -- | DSL accessor for the expressions field of hydra.lisp.syntax.BeginExpression beginExpressionExpressions :: Typed.TypedTerm Syntax.BeginExpression -> Typed.TypedTerm [Syntax.Expression] beginExpressionExpressions x =@@ -134,6 +146,10 @@           Core.fieldName = (Core.Name "expressions"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.lisp.syntax.BooleanStyle+booleanStyleBooleanStyle :: Typed.TypedName Syntax.BooleanStyle+booleanStyleBooleanStyle = Typed.TypedName (Core.Name "hydra.lisp.syntax.BooleanStyle")+ -- | DSL injection for the hashTF variant of hydra.lisp.syntax.BooleanStyle booleanStyleHashTF :: Typed.TypedTerm Syntax.BooleanStyle booleanStyleHashTF =@@ -183,6 +199,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.CaseClause+caseClauseCaseClause :: Typed.TypedName Syntax.CaseClause+caseClauseCaseClause = Typed.TypedName (Core.Name "hydra.lisp.syntax.CaseClause")+ -- | DSL accessor for the keys field of hydra.lisp.syntax.CaseClause caseClauseKeys :: Typed.TypedTerm Syntax.CaseClause -> Typed.TypedTerm [Syntax.Expression] caseClauseKeys x =@@ -242,6 +262,10 @@           Core.fieldName = (Core.Name "default"),           Core.fieldTerm = (Typed.unTypedTerm default_)}]})) +-- | DSL name token for hydra.lisp.syntax.CaseExpression+caseExpressionCaseExpression :: Typed.TypedName Syntax.CaseExpression+caseExpressionCaseExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.CaseExpression")+ -- | DSL accessor for the clauses field of hydra.lisp.syntax.CaseExpression caseExpressionClauses :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm [Syntax.CaseClause] caseExpressionClauses x =@@ -351,6 +375,10 @@           Core.fieldName = (Core.Name "value"),           Core.fieldTerm = (Typed.unTypedTerm value)}]})) +-- | DSL name token for hydra.lisp.syntax.CharacterLiteral+characterLiteralCharacterLiteral :: Typed.TypedName Syntax.CharacterLiteral+characterLiteralCharacterLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.CharacterLiteral")+ -- | DSL accessor for the value field of hydra.lisp.syntax.CharacterLiteral characterLiteralValue :: Typed.TypedTerm Syntax.CharacterLiteral -> Typed.TypedTerm String characterLiteralValue x =@@ -383,6 +411,10 @@           Core.fieldName = (Core.Name "text"),           Core.fieldTerm = (Typed.unTypedTerm text)}]})) +-- | DSL name token for hydra.lisp.syntax.Comment+commentComment :: Typed.TypedName Syntax.Comment+commentComment = Typed.TypedName (Core.Name "hydra.lisp.syntax.Comment")+ -- | DSL accessor for the style field of hydra.lisp.syntax.Comment commentStyle :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm Syntax.CommentStyle commentStyle x =@@ -401,6 +433,10 @@         Core.fieldName = (Core.Name "block"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.lisp.syntax.CommentStyle+commentStyleCommentStyle :: Typed.TypedName Syntax.CommentStyle+commentStyleCommentStyle = Typed.TypedName (Core.Name "hydra.lisp.syntax.CommentStyle")+ -- | DSL injection for the datum variant of hydra.lisp.syntax.CommentStyle commentStyleDatum :: Typed.TypedTerm Syntax.CommentStyle commentStyleDatum =@@ -484,6 +520,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.CondClause+condClauseCondClause :: Typed.TypedName Syntax.CondClause+condClauseCondClause = Typed.TypedName (Core.Name "hydra.lisp.syntax.CondClause")+ -- | DSL accessor for the condition field of hydra.lisp.syntax.CondClause condClauseCondition :: Typed.TypedTerm Syntax.CondClause -> Typed.TypedTerm Syntax.Expression condClauseCondition x =@@ -549,6 +589,10 @@         Core.projectionFieldName = (Core.Name "clauses")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.CondExpression+condExpressionCondExpression :: Typed.TypedName Syntax.CondExpression+condExpressionCondExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.CondExpression")+ -- | DSL accessor for the default field of hydra.lisp.syntax.CondExpression condExpressionDefault :: Typed.TypedTerm Syntax.CondExpression -> Typed.TypedTerm (Maybe Syntax.Expression) condExpressionDefault x =@@ -605,6 +649,10 @@           Core.fieldName = (Core.Name "tail"),           Core.fieldTerm = (Typed.unTypedTerm tail)}]})) +-- | DSL name token for hydra.lisp.syntax.ConsExpression+consExpressionConsExpression :: Typed.TypedName Syntax.ConsExpression+consExpressionConsExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.ConsExpression")+ -- | DSL accessor for the head field of hydra.lisp.syntax.ConsExpression consExpressionHead :: Typed.TypedTerm Syntax.ConsExpression -> Typed.TypedTerm Syntax.Expression consExpressionHead x =@@ -673,6 +721,10 @@           Core.fieldName = (Core.Name "doc"),           Core.fieldTerm = (Typed.unTypedTerm doc)}]})) +-- | DSL name token for hydra.lisp.syntax.ConstantDefinition+constantDefinitionConstantDefinition :: Typed.TypedName Syntax.ConstantDefinition+constantDefinitionConstantDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.ConstantDefinition")+ -- | DSL accessor for the doc field of hydra.lisp.syntax.ConstantDefinition constantDefinitionDoc :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring) constantDefinitionDoc x =@@ -803,6 +855,10 @@         Core.projectionFieldName = (Core.Name "constructor")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.ConstructorPattern+constructorPatternConstructorPattern :: Typed.TypedName Syntax.ConstructorPattern+constructorPatternConstructorPattern = Typed.TypedName (Core.Name "hydra.lisp.syntax.ConstructorPattern")+ -- | DSL updater for the arguments field of hydra.lisp.syntax.ConstructorPattern constructorPatternWithArguments :: Typed.TypedTerm Syntax.ConstructorPattern -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.ConstructorPattern constructorPatternWithArguments original newVal =@@ -850,6 +906,10 @@           Core.fieldName = (Core.Name "value"),           Core.fieldTerm = (Typed.unTypedTerm value)}]})) +-- | DSL name token for hydra.lisp.syntax.DestructuringBinding+destructuringBindingDestructuringBinding :: Typed.TypedName Syntax.DestructuringBinding+destructuringBindingDestructuringBinding = Typed.TypedName (Core.Name "hydra.lisp.syntax.DestructuringBinding")+ -- | DSL accessor for the pattern field of hydra.lisp.syntax.DestructuringBinding destructuringBindingPattern :: Typed.TypedTerm Syntax.DestructuringBinding -> Typed.TypedTerm Syntax.DestructuringPattern destructuringBindingPattern x =@@ -911,6 +971,10 @@         Core.fieldName = (Core.Name "associative"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.lisp.syntax.DestructuringPattern+destructuringPatternDestructuringPattern :: Typed.TypedName Syntax.DestructuringPattern+destructuringPatternDestructuringPattern = Typed.TypedName (Core.Name "hydra.lisp.syntax.DestructuringPattern")+ -- | DSL injection for the rest variant of hydra.lisp.syntax.DestructuringPattern destructuringPatternRest :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.DestructuringPattern destructuringPatternRest x =@@ -947,6 +1011,10 @@         Core.fieldName = (Core.Name "commonLisp"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.lisp.syntax.Dialect+dialectDialect :: Typed.TypedName Syntax.Dialect+dialectDialect = Typed.TypedName (Core.Name "hydra.lisp.syntax.Dialect")+ -- | DSL injection for the emacsLisp variant of hydra.lisp.syntax.Dialect dialectEmacsLisp :: Typed.TypedTerm Syntax.Dialect dialectEmacsLisp =@@ -975,6 +1043,10 @@           Core.fieldName = (Core.Name "expressions"),           Core.fieldTerm = (Typed.unTypedTerm expressions)}]})) +-- | DSL name token for hydra.lisp.syntax.DoExpression+doExpressionDoExpression :: Typed.TypedName Syntax.DoExpression+doExpressionDoExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.DoExpression")+ -- | DSL accessor for the expressions field of hydra.lisp.syntax.DoExpression doExpressionExpressions :: Typed.TypedTerm Syntax.DoExpression -> Typed.TypedTerm [Syntax.Expression] doExpressionExpressions x =@@ -1001,6 +1073,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.Docstring"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.Docstring+docstringDocstring :: Typed.TypedName Syntax.Docstring+docstringDocstring = Typed.TypedName (Core.Name "hydra.lisp.syntax.Docstring")+ -- | DSL constructor for hydra.lisp.syntax.DottedPair dottedPair :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DottedPair dottedPair car cdr =@@ -1032,6 +1108,10 @@         Core.projectionFieldName = (Core.Name "cdr")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.DottedPair+dottedPairDottedPair :: Typed.TypedName Syntax.DottedPair+dottedPairDottedPair = Typed.TypedName (Core.Name "hydra.lisp.syntax.DottedPair")+ -- | DSL updater for the car field of hydra.lisp.syntax.DottedPair dottedPairWithCar :: Typed.TypedTerm Syntax.DottedPair -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DottedPair dottedPairWithCar original newVal =@@ -1076,6 +1156,10 @@           Core.fieldName = (Core.Name "symbols"),           Core.fieldTerm = (Typed.unTypedTerm symbols)}]})) +-- | DSL name token for hydra.lisp.syntax.ExportDeclaration+exportDeclarationExportDeclaration :: Typed.TypedName Syntax.ExportDeclaration+exportDeclarationExportDeclaration = Typed.TypedName (Core.Name "hydra.lisp.syntax.ExportDeclaration")+ -- | DSL accessor for the symbols field of hydra.lisp.syntax.ExportDeclaration exportDeclarationSymbols :: Typed.TypedTerm Syntax.ExportDeclaration -> Typed.TypedTerm [Syntax.Symbol] exportDeclarationSymbols x =@@ -1167,6 +1251,10 @@         Core.fieldName = (Core.Name "dottedPair"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.lisp.syntax.Expression+expressionExpression :: Typed.TypedName Syntax.Expression+expressionExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.Expression")+ -- | DSL injection for the fieldAccess variant of hydra.lisp.syntax.Expression expressionFieldAccess :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Expression expressionFieldAccess x =@@ -1354,6 +1442,10 @@         Core.projectionFieldName = (Core.Name "field")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.FieldAccess+fieldAccessFieldAccess :: Typed.TypedName Syntax.FieldAccess+fieldAccessFieldAccess = Typed.TypedName (Core.Name "hydra.lisp.syntax.FieldAccess")+ -- | DSL accessor for the recordType field of hydra.lisp.syntax.FieldAccess fieldAccessRecordType :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Symbol fieldAccessRecordType x =@@ -1466,6 +1558,10 @@         Core.projectionFieldName = (Core.Name "defaultValue")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.FieldDefinition+fieldDefinitionFieldDefinition :: Typed.TypedName Syntax.FieldDefinition+fieldDefinitionFieldDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.FieldDefinition")+ -- | DSL accessor for the name field of hydra.lisp.syntax.FieldDefinition fieldDefinitionName :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm Syntax.Symbol fieldDefinitionName x =@@ -1522,6 +1618,10 @@           Core.fieldName = (Core.Name "precision"),           Core.fieldTerm = (Typed.unTypedTerm precision)}]})) +-- | DSL name token for hydra.lisp.syntax.FloatLiteral+floatLiteralFloatLiteral :: Typed.TypedName Syntax.FloatLiteral+floatLiteralFloatLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.FloatLiteral")+ -- | DSL accessor for the precision field of hydra.lisp.syntax.FloatLiteral floatLiteralPrecision :: Typed.TypedTerm Syntax.FloatLiteral -> Typed.TypedTerm (Maybe String) floatLiteralPrecision x =@@ -1617,6 +1717,10 @@         Core.projectionFieldName = (Core.Name "doc")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.FunctionDefinition+functionDefinitionFunctionDefinition :: Typed.TypedName Syntax.FunctionDefinition+functionDefinitionFunctionDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.FunctionDefinition")+ -- | DSL accessor for the name field of hydra.lisp.syntax.FunctionDefinition functionDefinitionName :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.Symbol functionDefinitionName x =@@ -1957,6 +2061,10 @@         Core.projectionFieldName = (Core.Name "else")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.IfExpression+ifExpressionIfExpression :: Typed.TypedName Syntax.IfExpression+ifExpressionIfExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.IfExpression")+ -- | DSL accessor for the then field of hydra.lisp.syntax.IfExpression ifExpressionThen :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression ifExpressionThen x =@@ -2051,6 +2159,10 @@           Core.fieldName = (Core.Name "spec"),           Core.fieldTerm = (Typed.unTypedTerm spec)}]})) +-- | DSL name token for hydra.lisp.syntax.ImportDeclaration+importDeclarationImportDeclaration :: Typed.TypedName Syntax.ImportDeclaration+importDeclarationImportDeclaration = Typed.TypedName (Core.Name "hydra.lisp.syntax.ImportDeclaration")+ -- | DSL accessor for the module field of hydra.lisp.syntax.ImportDeclaration importDeclarationModule :: Typed.TypedTerm Syntax.ImportDeclaration -> Typed.TypedTerm Syntax.NamespaceName importDeclarationModule x =@@ -2121,6 +2233,10 @@         Core.fieldName = (Core.Name "all"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.lisp.syntax.ImportSpec+importSpecImportSpec :: Typed.TypedName Syntax.ImportSpec+importSpecImportSpec = Typed.TypedName (Core.Name "hydra.lisp.syntax.ImportSpec")+ -- | DSL injection for the only variant of hydra.lisp.syntax.ImportSpec importSpecOnly :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.ImportSpec importSpecOnly x =@@ -2161,6 +2277,10 @@         Core.projectionFieldName = (Core.Name "bigint")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.IntegerLiteral+integerLiteralIntegerLiteral :: Typed.TypedName Syntax.IntegerLiteral+integerLiteralIntegerLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.IntegerLiteral")+ -- | DSL accessor for the value field of hydra.lisp.syntax.IntegerLiteral integerLiteralValue :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Integer integerLiteralValue x =@@ -2217,6 +2337,10 @@           Core.fieldName = (Core.Name "namespace"),           Core.fieldTerm = (Typed.unTypedTerm namespace)}]})) +-- | DSL name token for hydra.lisp.syntax.Keyword+keywordKeyword :: Typed.TypedName Syntax.Keyword+keywordKeyword = Typed.TypedName (Core.Name "hydra.lisp.syntax.Keyword")+ -- | DSL accessor for the name field of hydra.lisp.syntax.Keyword keywordName :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm String keywordName x =@@ -2297,6 +2421,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.Lambda+lambdaLambda :: Typed.TypedName Syntax.Lambda+lambdaLambda = Typed.TypedName (Core.Name "hydra.lisp.syntax.Lambda")+ -- | DSL accessor for the name field of hydra.lisp.syntax.Lambda lambdaName :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm (Maybe Syntax.Symbol) lambdaName x =@@ -2457,6 +2585,10 @@         Core.fieldName = (Core.Name "destructuring"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.lisp.syntax.LetBinding+letBindingLetBinding :: Typed.TypedName Syntax.LetBinding+letBindingLetBinding = Typed.TypedName (Core.Name "hydra.lisp.syntax.LetBinding")+ -- | DSL injection for the simple variant of hydra.lisp.syntax.LetBinding letBindingSimple :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.LetBinding letBindingSimple x =@@ -2509,6 +2641,10 @@         Core.projectionFieldName = (Core.Name "kind")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.LetExpression+letExpressionLetExpression :: Typed.TypedName Syntax.LetExpression+letExpressionLetExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.LetExpression")+ -- | DSL updater for the bindings field of hydra.lisp.syntax.LetExpression letExpressionWithBindings :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.LetBinding] -> Typed.TypedTerm Syntax.LetExpression letExpressionWithBindings original newVal =@@ -2581,6 +2717,10 @@               Core.projectionFieldName = (Core.Name "body")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL name token for hydra.lisp.syntax.LetKind+letKindLetKind :: Typed.TypedName Syntax.LetKind+letKindLetKind = Typed.TypedName (Core.Name "hydra.lisp.syntax.LetKind")+ -- | DSL injection for the parallel variant of hydra.lisp.syntax.LetKind letKindParallel :: Typed.TypedTerm Syntax.LetKind letKindParallel =@@ -2630,6 +2770,10 @@         Core.projectionFieldName = (Core.Name "elements")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.ListLiteral+listLiteralListLiteral :: Typed.TypedName Syntax.ListLiteral+listLiteralListLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.ListLiteral")+ -- | DSL accessor for the quoted field of hydra.lisp.syntax.ListLiteral listLiteralQuoted :: Typed.TypedTerm Syntax.ListLiteral -> Typed.TypedTerm Bool listLiteralQuoted x =@@ -2718,6 +2862,10 @@         Core.fieldName = (Core.Name "keyword"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.lisp.syntax.Literal+literalLiteral :: Typed.TypedName Syntax.Literal+literalLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.Literal")+ -- | DSL injection for the nil variant of hydra.lisp.syntax.Literal literalNil :: Typed.TypedTerm Syntax.Literal literalNil =@@ -2737,6 +2885,10 @@           Core.fieldName = (Core.Name "value"),           Core.fieldTerm = (Typed.unTypedTerm value)}]})) +-- | DSL name token for hydra.lisp.syntax.LiteralPattern+literalPatternLiteralPattern :: Typed.TypedName Syntax.LiteralPattern+literalPatternLiteralPattern = Typed.TypedName (Core.Name "hydra.lisp.syntax.LiteralPattern")+ -- | DSL accessor for the value field of hydra.lisp.syntax.LiteralPattern literalPatternValue :: Typed.TypedTerm Syntax.LiteralPattern -> Typed.TypedTerm Syntax.Literal literalPatternValue x =@@ -2802,6 +2954,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.MacroDefinition+macroDefinitionMacroDefinition :: Typed.TypedName Syntax.MacroDefinition+macroDefinitionMacroDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.MacroDefinition")+ -- | DSL accessor for the name field of hydra.lisp.syntax.MacroDefinition macroDefinitionName :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm Syntax.Symbol macroDefinitionName x =@@ -2975,6 +3131,10 @@         Core.projectionFieldName = (Core.Name "key")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.MapEntry+mapEntryMapEntry :: Typed.TypedName Syntax.MapEntry+mapEntryMapEntry = Typed.TypedName (Core.Name "hydra.lisp.syntax.MapEntry")+ -- | DSL accessor for the value field of hydra.lisp.syntax.MapEntry mapEntryValue :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression mapEntryValue x =@@ -3037,6 +3197,10 @@         Core.projectionFieldName = (Core.Name "entries")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.MapLiteral+mapLiteralMapLiteral :: Typed.TypedName Syntax.MapLiteral+mapLiteralMapLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.MapLiteral")+ -- | DSL updater for the entries field of hydra.lisp.syntax.MapLiteral mapLiteralWithEntries :: Typed.TypedTerm Syntax.MapLiteral -> Typed.TypedTerm [Syntax.MapEntry] -> Typed.TypedTerm Syntax.MapLiteral mapLiteralWithEntries original newVal =@@ -3069,6 +3233,10 @@         Core.projectionFieldName = (Core.Name "doc")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.ModuleDeclaration+moduleDeclarationModuleDeclaration :: Typed.TypedName Syntax.ModuleDeclaration+moduleDeclarationModuleDeclaration = Typed.TypedName (Core.Name "hydra.lisp.syntax.ModuleDeclaration")+ -- | DSL accessor for the name field of hydra.lisp.syntax.ModuleDeclaration moduleDeclarationName :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm Syntax.NamespaceName moduleDeclarationName x =@@ -3119,6 +3287,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.NamespaceName"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.NamespaceName+namespaceNameNamespaceName :: Typed.TypedName Syntax.NamespaceName+namespaceNameNamespaceName = Typed.TypedName (Core.Name "hydra.lisp.syntax.NamespaceName")+ -- | DSL injection for the emptyList variant of hydra.lisp.syntax.NilStyle nilStyleEmptyList :: Typed.TypedTerm Syntax.NilStyle nilStyleEmptyList =@@ -3137,6 +3309,10 @@         Core.fieldName = (Core.Name "nil"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.lisp.syntax.NilStyle+nilStyleNilStyle :: Typed.TypedName Syntax.NilStyle+nilStyleNilStyle = Typed.TypedName (Core.Name "hydra.lisp.syntax.NilStyle")+ -- | DSL constructor for hydra.lisp.syntax.NotExpression notExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.NotExpression notExpression expression =@@ -3156,6 +3332,10 @@         Core.projectionFieldName = (Core.Name "expression")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.NotExpression+notExpressionNotExpression :: Typed.TypedName Syntax.NotExpression+notExpressionNotExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.NotExpression")+ -- | DSL updater for the expression field of hydra.lisp.syntax.NotExpression notExpressionWithExpression :: Typed.TypedTerm Syntax.NotExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.NotExpression notExpressionWithExpression original newVal =@@ -3185,6 +3365,10 @@         Core.projectionFieldName = (Core.Name "expressions")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.OrExpression+orExpressionOrExpression :: Typed.TypedName Syntax.OrExpression+orExpressionOrExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.OrExpression")+ -- | DSL updater for the expressions field of hydra.lisp.syntax.OrExpression orExpressionWithExpressions :: Typed.TypedTerm Syntax.OrExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.OrExpression orExpressionWithExpressions original newVal =@@ -3213,6 +3397,10 @@         Core.fieldName = (Core.Name "literal"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.lisp.syntax.Pattern+patternPattern :: Typed.TypedName Syntax.Pattern+patternPattern = Typed.TypedName (Core.Name "hydra.lisp.syntax.Pattern")+ -- | DSL injection for the variable variant of hydra.lisp.syntax.Pattern patternVariable :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Pattern patternVariable x =@@ -3298,6 +3486,10 @@         Core.projectionFieldName = (Core.Name "module")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.Program+programProgram :: Typed.TypedName Syntax.Program+programProgram = Typed.TypedName (Core.Name "hydra.lisp.syntax.Program")+ -- | DSL updater for the dialect field of hydra.lisp.syntax.Program programWithDialect :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm Syntax.Dialect -> Typed.TypedTerm Syntax.Program programWithDialect original newVal =@@ -3519,6 +3711,10 @@         Core.projectionFieldName = (Core.Name "namespace")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.QualifiedSymbol+qualifiedSymbolQualifiedSymbol :: Typed.TypedName Syntax.QualifiedSymbol+qualifiedSymbolQualifiedSymbol = Typed.TypedName (Core.Name "hydra.lisp.syntax.QualifiedSymbol")+ -- | DSL updater for the name field of hydra.lisp.syntax.QualifiedSymbol qualifiedSymbolWithName :: Typed.TypedTerm Syntax.QualifiedSymbol -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.QualifiedSymbol qualifiedSymbolWithName original newVal =@@ -3572,6 +3768,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.QuasiquoteExpression+quasiquoteExpressionQuasiquoteExpression :: Typed.TypedName Syntax.QuasiquoteExpression+quasiquoteExpressionQuasiquoteExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.QuasiquoteExpression")+ -- | DSL updater for the body field of hydra.lisp.syntax.QuasiquoteExpression quasiquoteExpressionWithBody :: Typed.TypedTerm Syntax.QuasiquoteExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.QuasiquoteExpression quasiquoteExpressionWithBody original newVal =@@ -3601,6 +3801,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.QuoteExpression+quoteExpressionQuoteExpression :: Typed.TypedName Syntax.QuoteExpression+quoteExpressionQuoteExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.QuoteExpression")+ -- | DSL updater for the body field of hydra.lisp.syntax.QuoteExpression quoteExpressionWithBody :: Typed.TypedTerm Syntax.QuoteExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.QuoteExpression quoteExpressionWithBody original newVal =@@ -3654,6 +3858,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.RecordTypeDefinition+recordTypeDefinitionRecordTypeDefinition :: Typed.TypedName Syntax.RecordTypeDefinition+recordTypeDefinitionRecordTypeDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.RecordTypeDefinition")+ -- | DSL updater for the doc field of hydra.lisp.syntax.RecordTypeDefinition recordTypeDefinitionWithDoc :: Typed.TypedTerm Syntax.RecordTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.RecordTypeDefinition recordTypeDefinitionWithDoc original newVal =@@ -3744,6 +3952,10 @@         Core.fieldName = (Core.Name "list"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.lisp.syntax.SExpression+sExpressionSExpression :: Typed.TypedName Syntax.SExpression+sExpressionSExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.SExpression")+ -- | DSL constructor for hydra.lisp.syntax.SetLiteral setLiteral :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.SetLiteral setLiteral elements =@@ -3763,6 +3975,10 @@         Core.projectionFieldName = (Core.Name "elements")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.SetLiteral+setLiteralSetLiteral :: Typed.TypedName Syntax.SetLiteral+setLiteralSetLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.SetLiteral")+ -- | DSL updater for the elements field of hydra.lisp.syntax.SetLiteral setLiteralWithElements :: Typed.TypedTerm Syntax.SetLiteral -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.SetLiteral setLiteralWithElements original newVal =@@ -3795,6 +4011,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.SimpleBinding+simpleBindingSimpleBinding :: Typed.TypedName Syntax.SimpleBinding+simpleBindingSimpleBinding = Typed.TypedName (Core.Name "hydra.lisp.syntax.SimpleBinding")+ -- | DSL accessor for the value field of hydra.lisp.syntax.SimpleBinding simpleBindingValue :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.Expression simpleBindingValue x =@@ -3857,6 +4077,11 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.SplicingUnquoteExpression+splicingUnquoteExpressionSplicingUnquoteExpression :: Typed.TypedName Syntax.SplicingUnquoteExpression+splicingUnquoteExpressionSplicingUnquoteExpression =+    Typed.TypedName (Core.Name "hydra.lisp.syntax.SplicingUnquoteExpression")+ -- | DSL updater for the body field of hydra.lisp.syntax.SplicingUnquoteExpression splicingUnquoteExpressionWithBody :: Typed.TypedTerm Syntax.SplicingUnquoteExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SplicingUnquoteExpression splicingUnquoteExpressionWithBody original newVal =@@ -3874,6 +4099,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.Symbol"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.Symbol+symbolSymbol :: Typed.TypedName Syntax.Symbol+symbolSymbol = Typed.TypedName (Core.Name "hydra.lisp.syntax.Symbol")+ -- | DSL injection for the constant variant of hydra.lisp.syntax.TopLevelForm topLevelFormConstant :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm Syntax.TopLevelForm topLevelFormConstant x =@@ -3919,6 +4148,10 @@         Core.fieldName = (Core.Name "recordType"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.lisp.syntax.TopLevelForm+topLevelFormTopLevelForm :: Typed.TypedName Syntax.TopLevelForm+topLevelFormTopLevelForm = Typed.TypedName (Core.Name "hydra.lisp.syntax.TopLevelForm")+ -- | DSL injection for the variable variant of hydra.lisp.syntax.TopLevelForm topLevelFormVariable :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm Syntax.TopLevelForm topLevelFormVariable x =@@ -3971,6 +4204,11 @@         Core.projectionFieldName = (Core.Name "form")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.TopLevelFormWithComments+topLevelFormWithCommentsTopLevelFormWithComments :: Typed.TypedName Syntax.TopLevelFormWithComments+topLevelFormWithCommentsTopLevelFormWithComments =+    Typed.TypedName (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments")+ -- | DSL updater for the comment field of hydra.lisp.syntax.TopLevelFormWithComments topLevelFormWithCommentsWithComment :: Typed.TypedTerm Syntax.TopLevelFormWithComments -> Typed.TypedTerm (Maybe Syntax.Comment) -> Typed.TypedTerm Syntax.TopLevelFormWithComments topLevelFormWithCommentsWithComment original newVal =@@ -4074,6 +4312,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.TypeAnnotation+typeAnnotationTypeAnnotation :: Typed.TypedName Syntax.TypeAnnotation+typeAnnotationTypeAnnotation = Typed.TypedName (Core.Name "hydra.lisp.syntax.TypeAnnotation")+ -- | DSL updater for the expression field of hydra.lisp.syntax.TypeAnnotation typeAnnotationWithExpression :: Typed.TypedTerm Syntax.TypeAnnotation -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeAnnotation typeAnnotationWithExpression original newVal =@@ -4139,6 +4381,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.TypeHint+typeHintTypeHint :: Typed.TypedName Syntax.TypeHint+typeHintTypeHint = Typed.TypedName (Core.Name "hydra.lisp.syntax.TypeHint")+ -- | DSL updater for the name field of hydra.lisp.syntax.TypeHint typeHintWithName :: Typed.TypedTerm Syntax.TypeHint -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.TypeHint typeHintWithName original newVal =@@ -4245,6 +4491,10 @@         Core.fieldName = (Core.Name "set"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.lisp.syntax.TypeSpecifier+typeSpecifierTypeSpecifier :: Typed.TypedName Syntax.TypeSpecifier+typeSpecifierTypeSpecifier = Typed.TypedName (Core.Name "hydra.lisp.syntax.TypeSpecifier")+ -- | DSL injection for the unit variant of hydra.lisp.syntax.TypeSpecifier typeSpecifierUnit :: Typed.TypedTerm Syntax.TypeSpecifier typeSpecifierUnit =@@ -4294,6 +4544,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.UnquoteExpression+unquoteExpressionUnquoteExpression :: Typed.TypedName Syntax.UnquoteExpression+unquoteExpressionUnquoteExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.UnquoteExpression")+ -- | DSL updater for the body field of hydra.lisp.syntax.UnquoteExpression unquoteExpressionWithBody :: Typed.TypedTerm Syntax.UnquoteExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.UnquoteExpression unquoteExpressionWithBody original newVal =@@ -4347,6 +4601,10 @@         Core.projectionFieldName = (Core.Name "value")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.VariableDefinition+variableDefinitionVariableDefinition :: Typed.TypedName Syntax.VariableDefinition+variableDefinitionVariableDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.VariableDefinition")+ -- | DSL updater for the doc field of hydra.lisp.syntax.VariableDefinition variableDefinitionWithDoc :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.VariableDefinition variableDefinitionWithDoc original newVal =@@ -4450,6 +4708,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.VariableReference+variableReferenceVariableReference :: Typed.TypedName Syntax.VariableReference+variableReferenceVariableReference = Typed.TypedName (Core.Name "hydra.lisp.syntax.VariableReference")+ -- | DSL updater for the functionNamespace field of hydra.lisp.syntax.VariableReference variableReferenceWithFunctionNamespace :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.VariableReference variableReferenceWithFunctionNamespace original newVal =@@ -4503,6 +4765,10 @@         Core.projectionFieldName = (Core.Name "elements")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.lisp.syntax.VectorLiteral+vectorLiteralVectorLiteral :: Typed.TypedName Syntax.VectorLiteral+vectorLiteralVectorLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.VectorLiteral")+ -- | DSL updater for the elements field of hydra.lisp.syntax.VectorLiteral vectorLiteralWithElements :: Typed.TypedTerm Syntax.VectorLiteral -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.VectorLiteral vectorLiteralWithElements original newVal =@@ -4512,10 +4778,3 @@         Core.Field {           Core.fieldName = (Core.Name "elements"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))---- | DSL constructor for hydra.lisp.syntax.WildcardPattern-wildcardPattern :: Typed.TypedTerm Syntax.WildcardPattern-wildcardPattern =-    Typed.TypedTerm (Core.TermRecord (Core.Record {-      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.WildcardPattern"),-      Core.recordFields = []}))

@@ -57,24 +57,28 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | Dialect-aware name for "cadr" (second element of a list); Clojure uses "second", other dialects use "cadr" dialectCadr :: Syntax.Dialect -> String dialectCadr d =     case d of       Syntax.DialectClojure -> "second"       _ -> "cadr" +-- | Dialect-aware name for "car" (first element of a list); Clojure uses "first", other dialects use "car" dialectCar :: Syntax.Dialect -> String dialectCar d =     case d of       Syntax.DialectClojure -> "first"       _ -> "car" +-- | Dialect-aware constructor prefix for record types; Clojure uses "->", other dialects use "make-" dialectConstructorPrefix :: Syntax.Dialect -> String dialectConstructorPrefix d =     case d of       Syntax.DialectClojure -> "->"       _ -> "make-" +-- | Dialect-aware name for "equal?" (equality test): Clojure uses "=", Common Lisp/Emacs Lisp use "equal", Scheme uses "equal?" dialectEqual :: Syntax.Dialect -> String dialectEqual d =     case d of@@ -83,12 +87,14 @@       Syntax.DialectEmacsLisp -> "equal"       _ -> "equal?" +-- | Whether a dialect provides a native letrec (mutually recursive let); Clojure has only sequential let dialectSupportsLetrec :: Syntax.Dialect -> Bool dialectSupportsLetrec d =     case d of       Syntax.DialectClojure -> False       _ -> True +-- | Encode a function application, detecting ifElse and other lazy primitives; transforms (((hydra.lib.logic.ifElse C) T) E) into native (if C T E) encodeApplication :: Syntax.Dialect -> t0 -> Graph.Graph -> Core.Term -> Core.Term -> Either t1 Syntax.Expression encodeApplication dialect cx g rawFun rawArg = 

@@ -805,8 +805,13 @@           exports = Syntax.programExports prog           forms = Syntax.programForms prog           formPart = Lists.map (topLevelFormWithCommentsToExpr d) forms-          warning = [-                Serialization.cst (Strings.cat2 "; " Constants.warningAutoGeneratedFile)]+          warning =+                  case d of+                    Syntax.DialectEmacsLisp -> [+                      Serialization.cst ";; -*- lexical-binding: t -*-",+                      (Serialization.cst (Strings.cat2 "; " Constants.warningAutoGeneratedFile))]+                    _ -> [+                      Serialization.cst (Strings.cat2 "; " Constants.warningAutoGeneratedFile)]           importNames = Lists.map (\idecl -> Syntax.unNamespaceName (Syntax.importDeclarationModule idecl)) imports           exportSyms = Lists.concat (Lists.map (\edecl -> Lists.map symbolToExpr (Syntax.exportDeclarationSymbols edecl)) exports)       in case d of

@@ -734,9 +734,7 @@ _LiteralPattern_value = Core.Name "value"  -- | A wildcard pattern that matches any value-data WildcardPattern =-  WildcardPattern {}-  deriving (Eq, Ord, Read, Show)+type WildcardPattern = ()  _WildcardPattern = Core.Name "hydra.lisp.syntax.WildcardPattern"