diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,1372 @@
+# Hydra changelog
+
+All notable changes to the Hydra project are documented in this file.
+
+This changelog tracks changes across all Hydra implementations
+(Haskell, Java, Python, Scala, TypeScript, Clojure, Common Lisp, Emacs Lisp, Scheme)
+and supporting infrastructure.
+
+The format is inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and [Apache TinkerPop](https://github.com/apache/tinkerpop/blob/master/CHANGELOG.asciidoc).
+
+Pre-1.0 versions are listed below.
+Untagged versions correspond to in-repository version bumps that were not pushed as Git tags or Hackage releases;
+they are documented here for completeness.
+
+---
+
+## [0.17.0] - 2026-07-01
+
+Major themes: first-class support for effects and I/O in the kernel, TypeScript and
+Scala reaching publishable parity with the other hosts, and continued maturation of
+the published-host build model.
+
+### Highlights
+
+- **Effects and I/O** ([#286](https://github.com/CategoricalData/hydra/issues/286),
+  [#288](https://github.com/CategoricalData/hydra/issues/288),
+  [#494](https://github.com/CategoricalData/hydra/issues/494)): a new `effect` variant
+  on `hydra.core.Type` for representing effectful computations; new kernel modules
+  `hydra.file` (`FilePath`, `FileType`, `FileStatus`, `FileExtension`), `hydra.time`
+  (`Timespec`), and `hydra.error.file`; new primitive libraries `hydra.lib.effects`,
+  `hydra.lib.files`, and `hydra.lib.text` with byte-level I/O; and a new
+  `EffectfulTestCase` mechanism so the common test suite can exercise effectful
+  primitives across hosts.
+- **TypeScript is a complete implementation**
+  ([#462](https://github.com/CategoricalData/hydra/issues/462)): self-hosts and passes
+  the common test suite, with a per-package npm publish pipeline
+  ([#492](https://github.com/CategoricalData/hydra/issues/492)).
+- **Scala publishing**: per-package Maven Central publish infrastructure
+  ([#491](https://github.com/CategoricalData/hydra/issues/491)).
+- **Published-host build model**: published mode now compiles the kernel from the
+  co-generated `dist/haskell` rather than Hackage, removing the need for a
+  `haskell=local` shim ([#500](https://github.com/CategoricalData/hydra/issues/500));
+  the oil-and-water principle and cold-build workflow for `dist/haskell` are documented
+  ([#376](https://github.com/CategoricalData/hydra/issues/376)).
+- **Kernel hygiene**: `uniqueLabel` (apostrophe suffixes) replaced by `chooseUniqueLabel`
+  (numeric suffixes) in `hydra.names`
+  ([#436](https://github.com/CategoricalData/hydra/issues/436)).
+
+### Implementations
+
+Eight hosts self-host and pass the common test suite across five families: Haskell,
+Java, Python, Scala, and the four Lisp dialects (Clojure, Common Lisp, Scheme, Emacs
+Lisp), with TypeScript now joining as a complete host/target. Go remains a "head bud"
+(the coder still has emission bugs and the head's runtime is largely placeholder; it
+does not yet host the test suite).
+
+### New Features
+
+- Translingual cross-reference convention for `doc` strings: doc-escape tags render to
+  each host's native doc syntax (Javadoc, Haddock, Sphinx, TSDoc)
+  ([#433](https://github.com/CategoricalData/hydra/issues/433)).
+- Neo4j JSON-artifact validation demo, exercised across Java, Python, Haskell, and
+  TypeScript ([#510](https://github.com/CategoricalData/hydra/issues/510)).
+
+### Improvements
+
+- The Java/Maven publish set now covers every official Hydra target language, one coder
+  package per implementation family
+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).
+- JVM Maven artifact groups are bifurcated to `net.fortytwo.hydra.java` and
+  `net.fortytwo.hydra.scala`, so the Java and Scala (and future Clojure) publish sets
+  never collide on coordinates
+  ([#519](https://github.com/CategoricalData/hydra/issues/519)).
+- Host-specific third-party integrations (the former `bindings/` tree) are folded into
+  `overlay/`, unifying hand-written host-native source under one tree
+  ([#511](https://github.com/CategoricalData/hydra/issues/511)).
+- The coder de-parameterizes context and error types, simplifying generated coder
+  signatures ([#518](https://github.com/CategoricalData/hydra/issues/518)).
+- TypeScript-to-Java generation now emits the `hydra.lib.*` aggregate namespace
+  interfaces (`Maps`, `Strings`, etc.)
+  ([#499](https://github.com/CategoricalData/hydra/issues/499)).
+
+---
+
+## [0.16.1] - 2026-06-16
+
+Major themes: the first release built by bootstrapping from previously published
+packages, the first full 9 × 9 cross-implementation bootstrapping sweep, and
+published-package self-containment fixes for the artifacts that bootstrap rests on.
+
+### Highlights
+
+- **Bootstrap from published packages**: the build links the published 0.16.0 hosts
+  (Hackage / Maven Central / PyPI) and uses them to build the next version of Hydra,
+  resting on 0.16.0's forward-compatibility guarantees — the published-host consume
+  model with a `--local-host` shim, used for the first time in a release
+  ([#370](https://github.com/CategoricalData/hydra/issues/370)). 0.16.1 still builds
+  against **local** Haskell and Python hosts (`hostOverrides`), because the published
+  0.16.0 artifacts it would otherwise consume are the very ones being repaired below.
+- **First full 9 × 9 bootstrapping sweep** — every implementation generating every
+  other; dozens of cross-host issues surfaced and fixed
+  ([#409](https://github.com/CategoricalData/hydra/issues/409), ongoing).
+- **Published-package self-containment**: relocate each host's hand-written runtime
+  into `overlay/<lang>/hydra-kernel/` so it ships inside the published `hydra-kernel`
+  artifact — Python `hydra.python.util` into the wheel
+  ([#461](https://github.com/CategoricalData/hydra/issues/461),
+  [#472](https://github.com/CategoricalData/hydra/issues/472)) and the Haskell
+  authoring DSL + `Libraries`/`Terms` into the sdist
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)). Generalized to a
+  uniform `overlay/ = transform(packages) + copy(overlay)` model across all hosts
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- **Kernel self-containment via generated `hydra.lib.*` registries**: primitive
+  names are derived from generated `PrimitiveDefinition` def-modules rather than
+  hand-written name strings, in every host
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).
+- **In-memory encode/decode synthesis**: derived `hydra.{encode,decode}.*` modules
+  are synthesized at build time and excluded from `dist/`, with the synthesizer (not
+  inference) as the authority for their annotations
+  ([#448](https://github.com/CategoricalData/hydra/issues/448),
+  [#476](https://github.com/CategoricalData/hydra/issues/476)).
+- **Release hardening**: Apache source-release compliance (signed source archive,
+  LICENSE/NOTICE bundling, KEYS) ([#441](https://github.com/CategoricalData/hydra/issues/441)),
+  per-package publish orchestrators ([#449](https://github.com/CategoricalData/hydra/issues/449)),
+  and packaging-boundary verification gated in CI and at publish time
+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).
+
+### New features
+
+- Published-host consume model wired through `bin/sync.sh` for all three hosts
+  (`--published-host` default, `--local-host` shim), with the version basis keyed
+  off `hydra.json` and the `VERSION` file retired
+  ([#370](https://github.com/CategoricalData/hydra/issues/370),
+  [#347](https://github.com/CategoricalData/hydra/issues/347)).
+- Java and Python coder DSL sources made the sole source of truth; the legacy
+  Haskell DSL copies were deleted and cross-package references resolve by name
+  ([#346](https://github.com/CategoricalData/hydra/issues/346)).
+- Per-host `verify-distribution.sh` self-containment gates (Haskell stages the
+  per-package trio and `stack build`s it; Python installs the wheels into an
+  isolated venv and imports the kernel modules; Java resolves the published jars
+  from an offline consumer), run in CI and as a hard gate in `bin/prepare-release.sh`
+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).
+- Apache-compliant canonical source archive: signed + checksummed `git archive`
+  tarball as the release of record, root `NOTICE`, `KEYS`, and a release-verify CI
+  workflow ([#441](https://github.com/CategoricalData/hydra/issues/441)).
+- Per-package publish orchestrators `publish-maven.sh` / `publish-pypi.sh` with
+  dependency-closure and leaves-first ordering checks
+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).
+- `hydra-typescript` published as a target Java/Maven + PyPI artifact
+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).
+- Java coder emits a fluent builder for every generated record type
+  ([#465](https://github.com/CategoricalData/hydra/issues/465)); Python coder emits
+  per-field `with_<field>` copy-update methods and a fluent builder
+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).
+
+### Improvements
+
+- Drop the vestigial `InferenceContext` parameter from the `Primitive.implementation`
+  carrier across all hosts; add a graph-free `funT` coder and six `lists` default
+  implementations ([#446](https://github.com/CategoricalData/hydra/issues/446)).
+- Derive package routing from declared modules; split derived generation into broad
+  `mainDslModules` and scoped `mainEncodingModules`
+  ([#474](https://github.com/CategoricalData/hydra/issues/474),
+  [#475](https://github.com/CategoricalData/hydra/issues/475)).
+- Hash JSON content into the per-package input digest; add `digest-check
+  refresh-input` and a CI guard that force-regenerates and diffs
+  `dist/haskell/hydra-{java,python}` ([#469](https://github.com/CategoricalData/hydra/issues/469)).
+- Per-package inference seeds downstream packages from each package's full universe
+  while inferring only write targets, fixing `hydra-scala` inference within the CI
+  heap budget; declare the `hydra-java` dependency in `hydra-scala` for cold
+  ordering ([#470](https://github.com/CategoricalData/hydra/issues/470)).
+- Remove the vestigial `Lib/Defaults` registry and empty `defaultLibModules`
+  manifest field from all hosts ([#437](https://github.com/CategoricalData/hydra/issues/437)).
+- Bundle LICENSE + NOTICE into Java jars (`META-INF`) and Python wheels
+  (`dist-info`); declare Apache-2.0 in the Scala build
+  ([#441](https://github.com/CategoricalData/hydra/issues/441)).
+- Mark lazy parameters on the Scala and Common Lisp primitive registries so eager
+  coders thunk correctly ([#453](https://github.com/CategoricalData/hydra/issues/453),
+  [#477](https://github.com/CategoricalData/hydra/issues/477),
+  [#425](https://github.com/CategoricalData/hydra/issues/425)).
+- Staging-loop WIP-commit gate to keep `WIP:` commits off `origin/main`
+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).
+
+### Bug fixes
+
+- **Python wheel self-containment**: the `hydra-kernel` wheel now ships
+  `hydra.python.util`; gated by a packaging-boundary smoke test in CI and
+  `publish-pypi.sh` ([#472](https://github.com/CategoricalData/hydra/issues/472),
+  [#461](https://github.com/CategoricalData/hydra/issues/461)).
+- **Haskell sdist self-containment**: track the generated `Hydra/Dsl/Terms.hs`
+  (was gitignored) so the committed dist exports `ToPrimName`, fixing the cold
+  build of the published `hydra-kernel`
+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).
+- Decode synthesizer threads the fully-applied result type into wrap/record/union
+  decoder bodies, so derived decoders emit `DataRow<v>` rather than raw `DataRow`,
+  fixing Java and Scala generic decode compilation
+  ([#476](https://github.com/CategoricalData/hydra/issues/476)).
+- Scala coder emits explicit type arguments for polymorphic non-primitive
+  references under a type application (e.g. `requireField`), fixing `Any`-inference
+  of curried decoder lambda parameters in `decode/typed`
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- Common Lisp and Emacs Lisp: move the hand-written runtime to a dialect-tier path
+  so it no longer collides with the generated `hydra.lib.*` def-modules
+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).
+- Python coder uses the binding `TypeScheme` as the authoritative source for
+  parameter and return types ([#488](https://github.com/CategoricalData/hydra/issues/488));
+  fixes a duplicate `self` parameter in builders
+  ([#478](https://github.com/CategoricalData/hydra/issues/478)).
+- Sort term definitions by name in source-file generation so non-Haskell hosts emit
+  deterministic alphabetical Haskell output (host-independent of `Maps.elems`
+  iteration order) ([#489](https://github.com/CategoricalData/hydra/issues/489)).
+- Java coder serializes the `static` method modifier (previously a non-exhaustive
+  case) ([#465](https://github.com/CategoricalData/hydra/issues/465)); JavaDoc
+  `@link`/`@param` sanitization for strict doclint
+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).
+- Scala host writer appends a trailing newline when missing, fixing a Lisp-target
+  byte mismatch ([#463](https://github.com/CategoricalData/hydra/issues/463)).
+- Clojure host: silent wrapping `bigint_to_int{8,16,32,64}` casts per the kernel
+  contract ([#483](https://github.com/CategoricalData/hydra/issues/483)); load-order
+  and `--kernel-only` filter fixes after kernel renames
+  ([#425](https://github.com/CategoricalData/hydra/issues/425)); load the
+  `hydra-haskell` baseline for Clojure→Haskell rebuilds
+  ([#487](https://github.com/CategoricalData/hydra/issues/487),
+  [#460](https://github.com/CategoricalData/hydra/issues/460)).
+- Lisp-dialect bootstrap fixes: emit JSON object entries as 2-element `Pair` lists
+  rather than dotted cons ([#452](https://github.com/CategoricalData/hydra/issues/452),
+  also fixing [#16](https://github.com/CategoricalData/hydra/issues/16)); read
+  module names via the correct struct accessor
+  ([#471](https://github.com/CategoricalData/hydra/issues/471)); drop stale
+  surplus flag arguments from `generate-source-files` calls
+  ([#457](https://github.com/CategoricalData/hydra/issues/457),
+  [#458](https://github.com/CategoricalData/hydra/issues/458),
+  [#464](https://github.com/CategoricalData/hydra/issues/464)); rename eta-wrapped
+  projection/unwrap parameters to avoid kernel shadowing
+  ([#428](https://github.com/CategoricalData/hydra/issues/428)); propagate a
+  non-zero exit from the Scheme test runner on failures and fix Scheme float
+  scientific-notation formatting for `|x| >= 1e7`
+  ([#447](https://github.com/CategoricalData/hydra/issues/447)).
+- Cross-host target dispatch: Common Lisp and Clojure hosts dispatch Scala and
+  TypeScript targets ([#482](https://github.com/CategoricalData/hydra/issues/482),
+  [#483](https://github.com/CategoricalData/hydra/issues/483)); Scala/Java host
+  target-dispatch completions ([#5](https://github.com/CategoricalData/hydra/issues/5),
+  [#7](https://github.com/CategoricalData/hydra/issues/7),
+  [#17](https://github.com/CategoricalData/hydra/issues/17)).
+- TypeScript test runtime reads the kernel JSON field names `body`/`signature`
+  (not legacy `term`/`typeScheme`); `lists.nub` dedups by canonical JSON
+  ([#485](https://github.com/CategoricalData/hydra/issues/485)).
+- Sync robustness: always reassemble `dist/python` under `HYDRA_IN_SYNC` to heal
+  partial-dist state ([#480](https://github.com/CategoricalData/hydra/issues/480));
+  persist the run dir on bootstrap prep-phase failures
+  ([#481](https://github.com/CategoricalData/hydra/issues/481)); complete per-host
+  static deps so the bootstrap demo finds fresh dist
+  ([#445](https://github.com/CategoricalData/hydra/issues/445)).
+- Pin the Python target test interpreter to Python ≥ 3.12
+  ([#486](https://github.com/CategoricalData/hydra/issues/486)); Emacs Lisp / Scheme
+  target test-runner re-copy robustness
+  ([#456](https://github.com/CategoricalData/hydra/issues/456)).
+- JavaDoc Pages publish rewritten to build a combined site from the CI-generated
+  `dist/java/` artifact, fixing the failure mode where `pages.yml` ran against a
+  bare checkout with no `dist/java/` present
+  ([#450](https://github.com/CategoricalData/hydra/issues/450)).
+
+### Documentation
+
+- Document the `overlay/` self-containment model, the published-host consume model
+  for all three hosts, the `hydra.json` version / host-version basis, and a
+  migration-shims recipe ([#434](https://github.com/CategoricalData/hydra/issues/434),
+  [#370](https://github.com/CategoricalData/hydra/issues/370),
+  [#347](https://github.com/CategoricalData/hydra/issues/347)).
+- Document the kernel self-containment / `hydra.lib.*` def-module model and the
+  derived-module no-inference invariant
+  ([#473](https://github.com/CategoricalData/hydra/issues/473),
+  [#466](https://github.com/CategoricalData/hydra/issues/466)); generated Java and
+  Python record builders documented in the DSL guides
+  ([#465](https://github.com/CategoricalData/hydra/issues/465),
+  [#466](https://github.com/CategoricalData/hydra/issues/466)).
+- Use absolute GitHub URLs in package READMEs so links resolve when published
+  standalone ([#454](https://github.com/CategoricalData/hydra/issues/454)); bundle a
+  README into each Python package dir for sdist metadata
+  ([#418](https://github.com/CategoricalData/hydra/issues/418)).
+
+---
+
+## [0.16.0] - 2026-06-09
+
+Major themes: primitive-metadata reification, self-hosting coder DSLs with all
+eight hosts passing the common test suite, finalized `hydra.packaging`, and a
+deep kernel-vocabulary cleanup.
+
+### Highlights
+
+- **`PrimitiveDefinition` and per-namespace registry modules** with host-independent
+  specs for every standard-library primitive ([#156](https://github.com/CategoricalData/hydra/issues/156), [#319](https://github.com/CategoricalData/hydra/issues/319)).
+- **Self-hosting coder DSLs; all eight hosts pass the common test suite**, including
+  the completed TypeScript head ([#344](https://github.com/CategoricalData/hydra/issues/344), [#126](https://github.com/CategoricalData/hydra/issues/126)).
+- **Finalized `hydra.packaging`** and a unified `Module.dependencies` field ([#369](https://github.com/CategoricalData/hydra/issues/369), [#354](https://github.com/CategoricalData/hydra/issues/354)).
+- **Kernel-vocabulary cleanup**: `maybe`→`optional` across kernel and hosts, plus
+  order-preserving JSON objects ([#401](https://github.com/CategoricalData/hydra/issues/401), [#398](https://github.com/CategoricalData/hydra/issues/398)).
+
+### New features
+
+- Reify `PrimitiveDefinition` in `hydra.packaging` with per-namespace `hydra.lib.<sub>` registries ([#156](https://github.com/CategoricalData/hydra/issues/156)).
+- Host-independent `comments` specifications for all standard-library primitives ([#319](https://github.com/CategoricalData/hydra/issues/319)).
+- Kernel-oriented style checks in `hydra.validate.*` ([#321](https://github.com/CategoricalData/hydra/issues/321), [#351](https://github.com/CategoricalData/hydra/issues/351), [#352](https://github.com/CategoricalData/hydra/issues/352)), on a reshaped validation API ([#320](https://github.com/CategoricalData/hydra/issues/320)).
+- Promote the JSON Schema coder to a full DSL coder ([#350](https://github.com/CategoricalData/hydra/issues/350)).
+- Transpose coder sources into host-native DSLs for self-hosting ([#344](https://github.com/CategoricalData/hydra/issues/344), [#358](https://github.com/CategoricalData/hydra/issues/358)).
+- `Term`-typed annotations replacing `Map<Name, Term>` ([#386](https://github.com/CategoricalData/hydra/issues/386)).
+- Language-specific EDSL features on the kernel `Language` ([#233](https://github.com/CategoricalData/hydra/issues/233)).
+- Primitive-metadata-driven laziness in eager coders ([#391](https://github.com/CategoricalData/hydra/issues/391)).
+- `/test` skill and `bin/test.sh` for target-language test validation ([#387](https://github.com/CategoricalData/hydra/issues/387)).
+- Automatic differentiation: a `grad` transform ([#324](https://github.com/CategoricalData/hydra/issues/324)).
+- `hydra.show.error.pg` for `InvalidGraphError` ([#374](https://github.com/CategoricalData/hydra/issues/374)).
+
+### Improvements
+
+- Finalize `hydra.packaging`: `Binding`→`TypeDefinition`, `Module`/`Package` `comments`, `moduleName` cleanup ([#369](https://github.com/CategoricalData/hydra/issues/369), [#396](https://github.com/CategoricalData/hydra/issues/396), [#402](https://github.com/CategoricalData/hydra/issues/402), [#404](https://github.com/CategoricalData/hydra/issues/404)).
+- Merge `Module.termDependencies`/`typeDependencies` into one `dependencies` field ([#354](https://github.com/CategoricalData/hydra/issues/354)).
+- Resolve the `maybe`/`optional` ambiguity across kernel and all hosts ([#401](https://github.com/CategoricalData/hydra/issues/401)).
+- Order-preserving JSON objects; order-sensitive `Value` equality ([#398](https://github.com/CategoricalData/hydra/issues/398)).
+- Rename `Namespace`→`ModuleName` ([#316](https://github.com/CategoricalData/hydra/issues/316)) and the phantom DSL types to `Typed*` ([#397](https://github.com/CategoricalData/hydra/issues/397)).
+- Move from a type-class enum to type-class names ([#275](https://github.com/CategoricalData/hydra/issues/275)).
+- Repackage "eval lib" modules as kernel lib modules; promote remaining sources ([#260](https://github.com/CategoricalData/hydra/issues/260), [#355](https://github.com/CategoricalData/hydra/issues/355), [#356](https://github.com/CategoricalData/hydra/issues/356)).
+- Reshape `hydra.context` into `InferenceContext` ([#368](https://github.com/CategoricalData/hydra/issues/368)).
+- Streamline the Haskell, Java, Python, and Scala syntax models, re-pinning Java to SE 21 and Python to the 3.14 PEG grammar ([#297](https://github.com/CategoricalData/hydra/issues/297)).
+- Adopt persistent immutable collections across hosts ([#359](https://github.com/CategoricalData/hydra/issues/359), [#360](https://github.com/CategoricalData/hydra/issues/360), [#361](https://github.com/CategoricalData/hydra/issues/361), [#362](https://github.com/CategoricalData/hydra/issues/362)).
+- Migrate underscored kernel definition names to camelCase ([#348](https://github.com/CategoricalData/hydra/issues/348)).
+- Tidy qualified/unqualified imports in the Haskell DSL sources ([#308](https://github.com/CategoricalData/hydra/issues/308)).
+- Eliminate the `Hydra.Module.Compat` shim ([#315](https://github.com/CategoricalData/hydra/issues/315)).
+- Homogenize writer conventions across target languages ([#339](https://github.com/CategoricalData/hydra/issues/339)).
+- Disambiguate format-version field naming across JSON metadata ([#412](https://github.com/CategoricalData/hydra/issues/412)).
+- Per-package DSL→JSON build with per-package incremental inference ([#381](https://github.com/CategoricalData/hydra/issues/381), [#395](https://github.com/CategoricalData/hydra/issues/395)).
+- Prune stale `dist/` outputs; self-heal digests; exclude digests from VCS; reconcile drift; fail loud ([#357](https://github.com/CategoricalData/hydra/issues/357), [#393](https://github.com/CategoricalData/hydra/issues/393), [#405](https://github.com/CategoricalData/hydra/issues/405), [#378](https://github.com/CategoricalData/hydra/issues/378), [#379](https://github.com/CategoricalData/hydra/issues/379), [#392](https://github.com/CategoricalData/hydra/issues/392), [#414](https://github.com/CategoricalData/hydra/issues/414)).
+- Accept all valid (host, target) pairs in the generation drivers ([#421](https://github.com/CategoricalData/hydra/issues/421)).
+- Move Gradle build infrastructure into `heads/java/`; remove top-level `pixi.toml` ([#384](https://github.com/CategoricalData/hydra/issues/384), [#385](https://github.com/CategoricalData/hydra/issues/385)).
+- Eliminate post-generation test patches; fix loader/runner kludges; re-enable test timing ([#307](https://github.com/CategoricalData/hydra/issues/307), [#309](https://github.com/CategoricalData/hydra/issues/309), [#311](https://github.com/CategoricalData/hydra/issues/311)).
+- Performance/benchmarks and usability assessments ([#277](https://github.com/CategoricalData/hydra/issues/277), [#283](https://github.com/CategoricalData/hydra/issues/283)).
+- Split the Hackage distribution into per-package distributions ([#418](https://github.com/CategoricalData/hydra/issues/418)).
+
+### Bug fixes
+
+- Encode `uint32` JSON literals as numbers, not strings ([#431](https://github.com/CategoricalData/hydra/issues/431)).
+- Satisfy or suppress warnings in generated Java ([#349](https://github.com/CategoricalData/hydra/issues/349)).
+- Restore JSON parser test cases (polymorphic case handling, ordering fallback) ([#336](https://github.com/CategoricalData/hydra/issues/336)).
+- Keep annotations through `termAlternatives`/`typeAlternatives` adaptation ([#353](https://github.com/CategoricalData/hydra/issues/353)).
+- Scala host decodes module JSON containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).
+- Java coder: fix exponential `let`-bound `cases` cost ([#372](https://github.com/CategoricalData/hydra/issues/372)) and explicit type args on `PersistentMap.ofEntries` ([#394](https://github.com/CategoricalData/hydra/issues/394)).
+- Python-host codegen: drop extra `pyStringToPyStrings` wrapping ([#367](https://github.com/CategoricalData/hydra/issues/367)).
+- `escape_literal_char` no longer mangles RDF triples ([#363](https://github.com/CategoricalData/hydra/issues/363)).
+- Sync robustness: stale coder JSON, omitted native modules, dead helper, bad source dirs ([#406](https://github.com/CategoricalData/hydra/issues/406), [#400](https://github.com/CategoricalData/hydra/issues/400), [#411](https://github.com/CategoricalData/hydra/issues/411), [#408](https://github.com/CategoricalData/hydra/issues/408)).
+- Cross-host self-hosting fixes (Scala, TypeScript, and the four Lisp dialects) ([#422](https://github.com/CategoricalData/hydra/issues/422), [#423](https://github.com/CategoricalData/hydra/issues/423), [#424](https://github.com/CategoricalData/hydra/issues/424), [#429](https://github.com/CategoricalData/hydra/issues/429), [#444](https://github.com/CategoricalData/hydra/issues/444), [#366](https://github.com/CategoricalData/hydra/issues/366), [#389](https://github.com/CategoricalData/hydra/issues/389), [#407](https://github.com/CategoricalData/hydra/issues/407), [#425](https://github.com/CategoricalData/hydra/issues/425), [#426](https://github.com/CategoricalData/hydra/issues/426), [#427](https://github.com/CategoricalData/hydra/issues/427), [#432](https://github.com/CategoricalData/hydra/issues/432), [#438](https://github.com/CategoricalData/hydra/issues/438), [#439](https://github.com/CategoricalData/hydra/issues/439), [#443](https://github.com/CategoricalData/hydra/issues/443)).
+
+### Removed
+
+- Removed the `bigfloat` literal type from `FloatType` and `FloatValue` ([#330](https://github.com/CategoricalData/hydra/issues/330)).
+  Arbitrary-precision floating-point values were inconsistently supported
+  across host languages (Java/Scala in particular lacked a true IEEE 754
+  arbitrary-precision implementation), and nothing in the codebase relied on
+  them. `FloatType` and `FloatValue` now have only `float32` and `float64`
+  variants. Removed library primitives: `bigfloatToBigint`, `bigfloatToFloat32`,
+  `bigfloatToFloat64`, `bigintToBigfloat`, `float32ToBigfloat`,
+  `float64ToBigfloat`, `readBigfloat`, `showBigfloat`, `roundBigfloat`. New
+  primitives `float32ToFloat64` and `float64ToFloat32` (the latter lossy)
+  replace the removed bigfloat-routed conversions.
+- Removed `heads/haskell/bin/assemble-hackage-sdist.sh` ([#418](https://github.com/CategoricalData/hydra/issues/418)), the 0.15-era
+  bridge that flattened the multi-source-dir Haskell head into one self-contained
+  `hydra` sdist. Superseded by the per-package assembler (see Improvements).
+
+### Documentation
+
+- Comprehensive documentation refresh for 0.16 ([#383](https://github.com/CategoricalData/hydra/issues/383))
+  spanning nine tracks across READMEs, `docs/`, the wiki, CLAUDE.md, and
+  in-source kernel comments.
+- New `docs/json-format.md` reference describing the canonical JSON wire format
+  (tagged-union duality, optional-field rules, IEEE 754 sentinels, integer
+  threshold).
+- New wiki pages: `Design` (rationale behind each major choice) and `Inference`
+  (HM type inference with class constraints).
+- Cross-checked every prose doc against current code; corrected drift in
+  primitive-checking sections of `docs/recipes/maintenance.md`, the `Primitive`
+  shape in `docs/implementation.md` and `docs/recipes/adding-primitives.md`,
+  and the build-system narrative.
+- Wove motivation ("the why") through the existing doc surface rather than
+  collecting it into separately-titled sidebars; landed an inference-overview
+  centerpiece on the wiki ([#377](https://github.com/CategoricalData/hydra/issues/377)).
+- Aligned doc vocabulary with the LambdaGraph paper and the literature review
+  for the design space Hydra inhabits.
+- Net-new READMEs for `packages/hydra-kernel`, `packages/hydra-ext`,
+  `packages/hydra-coq`, and `packages/hydra-wasm`; top-level `README.md`
+  now carries a canonical packages table.
+- Audited and refreshed the Claude surface: CLAUDE.md "Where to look up X"
+  table extended with rows for `docs/getting-started.md`, `docs/json-format.md`,
+  and the `Design` / `Inference` wiki pages; hard-rules block reordered by
+  violation frequency; `claude/pitfalls.md` superseded entries folded into
+  `docs/troubleshooting.md` / recipes.
+- Project-descriptor strings reviewed and aligned across 24 build / packaging
+  files (Hackage synopsis, Maven Central description, PyPI / conda-forge
+  classifiers, Hydra-format `package.json` files).
+- `docs/index.html` (the GitHub Pages landing page) refreshed with audience
+  hops into wiki Concepts / Design, `docs/getting-started.md`, and the GitHub
+  repo, plus the full published-artifact list across Hackage, Maven Central,
+  PyPI, and conda-forge.
+- In-source kernel-code rationale comments added at key Sources sites covering
+  injection / pair / either / unit-void duality, error taxonomy, variant
+  records, inference-context threading, validation profiles, reduction state,
+  lexical filters, name mangling, scoping, variable handling, defaults
+  integration, and Tarjan SCC choice rationale. JSON encode/decode modules
+  cross-reference `docs/json-format.md`.
+- Filed `Primitive.implementation` carrier-simplification follow-up
+  ([#446](https://github.com/CategoricalData/hydra/issues/446))
+  to drop the unused `InferenceContext` and `Graph` parameters once the
+  `Lib/Defaults/` integration ([#437](https://github.com/CategoricalData/hydra/issues/437))
+  lands.
+
+---
+
+## [0.15.0] - 2026-04-29
+
+A structural-cleanup release.
+The repository is reorganized into a three-tree
+`packages/` (DSL sources) / `heads/` (per-host runtime) / `dist/` (generated output)
+layout ([#290](https://github.com/CategoricalData/hydra/issues/290)), the kernel is simplified ([#251](https://github.com/CategoricalData/hydra/issues/251), [#292](https://github.com/CategoricalData/hydra/issues/292), [#332](https://github.com/CategoricalData/hydra/issues/332)), and Java + Python now
+ship as per-package publishable artifacts on Maven Central / PyPI / conda-forge
+([#305](https://github.com/CategoricalData/hydra/issues/305)).
+Incremental, content-hash-based caches accelerate the sync pipeline ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+Three new generation-only targets — Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)), and an
+automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)) — are in progress as Claude collaborations.
+
+### Highlights
+
+- **Three-tree repository layout**: `packages/` (DSL), `heads/` (host runtime),
+  `dist/` (generated) ([#290](https://github.com/CategoricalData/hydra/issues/290)).
+- **Per-package distributions** for Java (4 Maven artifacts) and Python (5 wheels):
+  `hydra-kernel`, `hydra-pg`, `hydra-rdf`, `hydra-{java,python}`, plus `hydra-ext`
+  on PyPI ([#305](https://github.com/CategoricalData/hydra/issues/305)).
+- **Kernel simplifications**: `Function`/`Elimination` removed ([#332](https://github.com/CategoricalData/hydra/issues/332)),
+  `FunctionPrimitive` removed ([#251](https://github.com/CategoricalData/hydra/issues/251)), `Hydra.Ext.*` prefix retired ([#331](https://github.com/CategoricalData/hydra/issues/331)),
+  `Context` error wrapper gone ([#292](https://github.com/CategoricalData/hydra/issues/292)).
+- **Incremental caches** across the sync pipeline; ~70x speedup on no-op resync ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+- **JSON kernel format v1** with formal wire-format spec and four-field rename ([#343](https://github.com/CategoricalData/hydra/issues/343)).
+- **Three new generation-only targets** (in progress): Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)),
+  automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)).
+
+### New features
+
+- Per-package distributions ([#305](https://github.com/CategoricalData/hydra/issues/305)): standalone Maven / PyPI / conda-forge builds,
+  generated `build.gradle` / `pyproject.toml` per package, transitive dep resolution.
+- JSON kernel format v1 ([#343](https://github.com/CategoricalData/hydra/issues/343)): formal spec at `docs/json-format.md`,
+  four-field rename to `typeScheme`, `Module` field reorder, `formatVersion` stamp.
+- `decimal` literal type in the kernel ([#338](https://github.com/CategoricalData/hydra/issues/338)) across all hosts.
+- Type-directed JSON encoder with idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314), [#318](https://github.com/CategoricalData/hydra/issues/318)).
+- Incremental type inference plus content-hash caches ([#247](https://github.com/CategoricalData/hydra/issues/247)).
+- Coq generation target ([#326](https://github.com/CategoricalData/hydra/issues/326), in progress): `hydra-coq` package, 131/131 `.v` files pass `coqc`.
+- WebAssembly target ([#325](https://github.com/CategoricalData/hydra/issues/325), in progress): `hydra-wasm` package, M4 closure mechanism.
+- Automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324), in progress): symbolic source-to-source.
+- `hydra.show.error` module ([#265](https://github.com/CategoricalData/hydra/issues/265)): consolidated error-message builders.
+- `hydra.lib.maybes.toList` primitive ([#257](https://github.com/CategoricalData/hydra/issues/257)).
+- NaN / Inf round-tripping through JSON and per-language serdes ([#312](https://github.com/CategoricalData/hydra/issues/312), [#318](https://github.com/CategoricalData/hydra/issues/318), [#330](https://github.com/CategoricalData/hydra/issues/330)).
+- Typeclass inference test group ([#274](https://github.com/CategoricalData/hydra/issues/274)).
+- Term and type linters ([#232](https://github.com/CategoricalData/hydra/issues/232)).
+- Validation for modules and graphs ([#155](https://github.com/CategoricalData/hydra/issues/155)).
+- User-defined-function (UDF) support and DSL-vs-primitive overrides
+  ([#62](https://github.com/CategoricalData/hydra/issues/62), [#63](https://github.com/CategoricalData/hydra/issues/63), [#102](https://github.com/CategoricalData/hydra/issues/102), [#158](https://github.com/CategoricalData/hydra/issues/158)).
+- Stale-source detection across sync entrypoints ([#228](https://github.com/CategoricalData/hydra/issues/228)).
+
+### Improvements
+
+- Sync infrastructure: matrix tool, per-package orchestrator, per-language wrappers ([#290](https://github.com/CategoricalData/hydra/issues/290)).
+- TestGraph post-generation patches eliminated; DSL emits `TestEnv` refs directly.
+- Minimized standard imports in generated Haskell ([#161](https://github.com/CategoricalData/hydra/issues/161)); improved auto-aliases ([#322](https://github.com/CategoricalData/hydra/issues/322)).
+- Removed kernel term dependencies from the interpreter ([#257](https://github.com/CategoricalData/hydra/issues/257)).
+- Removed `Graph` and `Context` arguments from primitive implementations ([#266](https://github.com/CategoricalData/hydra/issues/266)).
+- Refactored kernel term modules: split rewriting/schemas, renamed show.meta → codegen,
+  moved `Coder` to `coders`, merged `extract.helpers` ([#221](https://github.com/CategoricalData/hydra/issues/221)).
+- Removed Aeson and HsYAML dependencies; YAML coder moved to `hydra-ext` ([#261](https://github.com/CategoricalData/hydra/issues/261)).
+- Lisp recursive let bindings via SCC ([#341](https://github.com/CategoricalData/hydra/issues/341)); parenthesis cleanup ([#84](https://github.com/CategoricalData/hydra/issues/84)).
+- Everything-to-everything bootstrapping demo ([#254](https://github.com/CategoricalData/hydra/issues/254)).
+- Re-enabled skipped Python tests; `disabledForPython` retired ([#263](https://github.com/CategoricalData/hydra/issues/263)).
+- Promoted host-specific code in `packages/` into per-head locations ([#337](https://github.com/CategoricalData/hydra/issues/337)).
+- Migrated `hydra.common` Java module out ([#10](https://github.com/CategoricalData/hydra/issues/10)).
+- Test infrastructure unification under `UniversalTestCase` ([#246](https://github.com/CategoricalData/hydra/issues/246)).
+- Default property graph → RDF mapping ([#296](https://github.com/CategoricalData/hydra/issues/296)).
+- 13 unsafe partial primitives replaced with `Maybe`-returning alternatives ([#201](https://github.com/CategoricalData/hydra/issues/201)).
+- Java generated code uses standard `java.util` collection interfaces ([#313](https://github.com/CategoricalData/hydra/issues/313)).
+- `Term.union` renamed to `Term.inject` ([#334](https://github.com/CategoricalData/hydra/issues/334)).
+- Inconsistencies in domain DSLs cleaned up ([#219](https://github.com/CategoricalData/hydra/issues/219)).
+- Coder packages moved out of hydra-haskell ([#182](https://github.com/CategoricalData/hydra/issues/182)).
+- Java package-naming scheme revised ([#223](https://github.com/CategoricalData/hydra/issues/223)).
+- Decimal used (instead of bigfloat) for JSON numbers ([#340](https://github.com/CategoricalData/hydra/issues/340)).
+- Hydra kernel moved out of hydra-haskell ([#282](https://github.com/CategoricalData/hydra/issues/282)).
+
+### Bug fixes
+
+- `substInTypeScheme` capture-unsafe substitution under nested forall binders.
+- Java `Float64` arithmetic primitives corrected for current `PrimitiveFunction` API.
+- Clojure decimal handling: value-based equality, `BigInteger` return from `decimal_to_bigint`.
+- Scheme runtime R7RS imports for `sets.scm` / `maps.scm` / `eithers.map_set`.
+- Python coder defaults corrected from `Py.Name` to `Py.Expression`.
+- Scala host JSON-decode failure on modules containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).
+- Lisp coder mutually-recursive let bindings for Clojure ([#341](https://github.com/CategoricalData/hydra/issues/341)).
+
+### Documentation
+
+- Documentation refresh for the 0.15 packaging restructure ([#290](https://github.com/CategoricalData/hydra/issues/290), [#331](https://github.com/CategoricalData/hydra/issues/331)); CLAUDE.md,
+  READMEs, recipes, demos, and seven wiki pages updated.
+- Code-generation recipe rewritten for the per-package dist layout ([#282](https://github.com/CategoricalData/hydra/issues/282)).
+- New `maintenance.md` recipe consolidates non-source-file scans, stale generated
+  detection, design-violation checks, and freshness checks.
+- Documentation style guide added at `docs/documentation-style-guide.md`.
+- Cross-worktree messaging protocol documented in CLAUDE.md.
+- Decimal type documented in the lexicon and per-language READMEs ([#338](https://github.com/CategoricalData/hydra/issues/338)).
+- JSON encoding format docs updated for idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314)).
+
+---
+
+## [0.14.1] - 2026-03-30
+
+Patch release.
+Regenerates all implementations after a fix to the group eval primitive ([#281](https://github.com/CategoricalData/hydra/issues/281)),
+and relocates the property-graph and RDF/SHACL "ext" modules into hydra-java and hydra-python.
+
+### Improvements
+
+- Moved PG, RDF, and SHACL ext modules from hydra-ext into hydra-java and hydra-python.
+
+### Bug fixes
+
+- Group eval primitive fix; all targets regenerated ([#281](https://github.com/CategoricalData/hydra/issues/281)).
+- JavaDoc HTML-entity escaping in generated `DestructuringPattern.java`.
+
+---
+
+## [0.14.0] - 2026-03-29
+
+Major release adding four new complete Hydra implementations — Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)),
+Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, and Scheme — bringing the total to seven bootstrapping hosts
+(plus Emacs Lisp, which passes the test suite but does not yet participate in bootstrapping).
+Also includes kernel simplifications, an Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)),
+eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)), new demos, and significant performance work on the Scheme host.
+
+### Highlights
+
+- **Four new complete implementations**: Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)), Hydra-Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)),
+  Hydra-Common Lisp, and Hydra-Scheme pass the common test suite and can serve as
+  bootstrapping hosts.
+  The four Lisp dialects share a single coder and serializer.
+- **Kernel simplifications**: removed `RowType`/`WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)),
+  unified `Graph`/`TypeContext`/`InferenceContext` ([#192](https://github.com/CategoricalData/hydra/issues/192)),
+  replaced `Module.elements` with `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)),
+  consolidated error types ([#268](https://github.com/CategoricalData/hydra/issues/268)), and promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).
+- **Avro bidirectional coder** ([#301](https://github.com/CategoricalData/hydra/issues/301)) with property graph pipeline demo.
+- **Scheme bootstrap performance**: 58 minutes → 5.7 minutes via O(1) vhash data structures
+  and IEEE 754 float precision fixes.
+
+### Breaking changes
+
+- Removed legacy adapter framework; replaced by the staging-promoted variant ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).
+- Replaced legacy Flow monad with Either ([#245](https://github.com/CategoricalData/hydra/issues/245)).
+- Removed `Module.elements`; use `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)).
+- Removed `RowType` and `WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)).
+- Renamed `hydra.accessors` to `hydra.paths` ([#271](https://github.com/CategoricalData/hydra/issues/271)).
+- Renamed `hydra.tarjan` and merged into `hydra.sorting` ([#220](https://github.com/CategoricalData/hydra/issues/220)).
+- Merged `hydra.constraints` into `hydra.query` ([#272](https://github.com/CategoricalData/hydra/issues/272)).
+- Moved `hydra.workflow` to hydra-ext ([#270](https://github.com/CategoricalData/hydra/issues/270)).
+- Consolidated `hydra.compute` into `hydra.util` ([#269](https://github.com/CategoricalData/hydra/issues/269)).
+- Removed `hydra.describe` ([#216](https://github.com/CategoricalData/hydra/issues/216)) and types from `hydra.mantle` ([#217](https://github.com/CategoricalData/hydra/issues/217)).
+- Replaced `OtherError` with task-specific error types ([#268](https://github.com/CategoricalData/hydra/issues/268)).
+- Java: lowered minimum Java version to 11 ([#249](https://github.com/CategoricalData/hydra/issues/249)).
+- Java: `Pair` replaces `Tuple2` ([#252](https://github.com/CategoricalData/hydra/issues/252)); `Comparable` implemented for generated classes ([#131](https://github.com/CategoricalData/hydra/issues/131)).
+
+### New features
+
+- Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)): complete implementation, sbt/Scala 3, 3043 tests.
+- Hydra-Lisp: Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, Emacs Lisp, Scheme — four dialects,
+  one coder. CI workflows for Clojure, Common Lisp, and Scheme.
+- Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)) with demo.
+- Eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)): Logic, Equality, Math, collections, and Groups.
+- Generated DSL modules ([#180](https://github.com/CategoricalData/hydra/issues/180)): `hydra.dsls` generates DSL helpers from type modules.
+- New demos: GraphQL+JSON ([#279](https://github.com/CategoricalData/hydra/issues/279)), PG validation ([#284](https://github.com/CategoricalData/hydra/issues/284)), SHACL ([#294](https://github.com/CategoricalData/hydra/issues/294)), Avro+PG.
+- Packaging module ([#290](https://github.com/CategoricalData/hydra/issues/290)): `hydra.packaging` with `Package` type and validation.
+- New primitives: `lists.foldr` ([#280](https://github.com/CategoricalData/hydra/issues/280)), `maybes.toList`, float rounding ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).
+- Cross-language benchmarking suite ([#234](https://github.com/CategoricalData/hydra/issues/234)).
+- Limited typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)).
+- Standardized validation patterns across modules ([#291](https://github.com/CategoricalData/hydra/issues/291)).
+
+### Improvements
+
+- Promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).
+- Removed legacy adapters, JSON/YAML coders, grammar framework ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).
+- Java: efficient immutable data structures ([#193](https://github.com/CategoricalData/hydra/issues/193)); flattened term naming.
+- Java: hidden specialized collection classes in type-level files ([#313](https://github.com/CategoricalData/hydra/issues/313)).
+- Inference error messages improved ([#231](https://github.com/CategoricalData/hydra/issues/231)).
+- Combined nested let bindings in the Haskell coder ([#248](https://github.com/CategoricalData/hydra/issues/248)).
+- Simplified `hydra.adapt.simple` ([#255](https://github.com/CategoricalData/hydra/issues/255)).
+- Removed Haskell operators dependency from tests ([#288](https://github.com/CategoricalData/hydra/issues/288)).
+- Regression tests for non-Haskell/Java coders ([#85](https://github.com/CategoricalData/hydra/issues/85)).
+- Regex support added ([#293](https://github.com/CategoricalData/hydra/issues/293)).
+- `hydra.annotations.isNativeType` revisited ([#214](https://github.com/CategoricalData/hydra/issues/214)).
+- Migrated grammar-generated models ([#295](https://github.com/CategoricalData/hydra/issues/295)).
+- `<<= -shouldBe-> <<~` operator change ([#276](https://github.com/CategoricalData/hydra/issues/276)).
+- Minimize Generation.hs ([#225](https://github.com/CategoricalData/hydra/issues/225)).
+- Implemented missing Flows primitives ([#183](https://github.com/CategoricalData/hydra/issues/183)).
+- Removed JavaDocs from the repository ([#262](https://github.com/CategoricalData/hydra/issues/262)).
+- Floating-point test portability fixes for Linux CI ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).
+- Moved YAML coder to hydra-ext ([#224](https://github.com/CategoricalData/hydra/issues/224)).
+- Minimized native Python and Java primitives in favor of DSL implementations ([#244](https://github.com/CategoricalData/hydra/issues/244)).
+- Removed the `disabledForPython` test tag ([#250](https://github.com/CategoricalData/hydra/issues/250)).
+
+### Release tooling
+
+- 0.14 release tracking ([#304](https://github.com/CategoricalData/hydra/issues/304)).
+
+### Documentation
+
+- Thorough cleanup of user documentation ([#302](https://github.com/CategoricalData/hydra/issues/302), [#303](https://github.com/CategoricalData/hydra/issues/303)).
+- Coding style guide added to wiki.
+- Updated 'new implementation' recipe with learnings from Clojure head ([#278](https://github.com/CategoricalData/hydra/issues/278)).
+
+---
+
+## [0.13.0] - 2026-02-27
+
+Major release completing Hydra-Python ([#66](https://github.com/CategoricalData/hydra/issues/66)) and Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)) as self-hosting Hydra implementations
+and demonstrating mutual self-hosting across all three languages.
+Significant improvements to type inference, type checking, rewriting, and adaptation.
+New language features include first-class Either types, typeclass inference, binary data support,
+and a native JSON parser/writer.
+Comprehensive tooling for cross-implementation bootstrapping
+and provisional support for Go, Rust, and JavaScript targets.
+
+### Highlights
+
+- **Mutual self-hosting across three implementations**: Hydra is now fully self-hosting
+  in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)), Java, and Python, and can cross-generate between every combination
+  of host and target language (9 paths total).
+- **Hydra-Java is complete** ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass.
+- **Hydra-Python is complete** ([#66](https://github.com/CategoricalData/hydra/issues/66)): 100% test parity with Haskell.
+- **Language coders promoted into the Hydra kernel** ([#176](https://github.com/CategoricalData/hydra/issues/176)): Haskell, Java, and Python
+  coders are now defined as Hydra DSL modules, making them self-hosting.
+- **Either type support** ([#210](https://github.com/CategoricalData/hydra/issues/210)) with full inference, checking, and library support.
+- **Native JSON parser and writer** ([#188](https://github.com/CategoricalData/hydra/issues/188), [#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)): Hydra's own JSON parser and writer
+  replace the Aeson dependency; bootstrap-from-JSON architecture for cross-implementation
+  code generation.
+
+### Breaking changes
+
+- Renamed `Optional` to `Maybe` throughout the codebase ([#204](https://github.com/CategoricalData/hydra/issues/204)):
+  `hydra.lib.optionals` → `hydra.lib.maybes`; all `optional` variants renamed to `maybe`.
+- Removed unlabeled product and sum types; replaced with pair types ([#212](https://github.com/CategoricalData/hydra/issues/212)).
+- Renamed `hydra.core.TypedTerm` to `hydra.core.TypeApplicationTerm`.
+- Renamed `hydra.json` to `hydra.json.model`.
+- Renamed `hydra.lib.maps.remove` to `hydra.lib.maps.delete`.
+- Removed deprecated `hydra.decoding` module.
+- Removed old `hydra.mantle.Either` type (replaced by core `Either`).
+- Removed `hydra.lib.tuples` library.
+- Removed C# coder stub (C# syntax model remains).
+- DSL syntax migration: removed `OverloadedStrings` for term expressions ([#238](https://github.com/CategoricalData/hydra/issues/238)).
+- Removed `Hydra.Dsl.ShorthandTypes` ([#222](https://github.com/CategoricalData/hydra/issues/222)).
+
+### New features
+
+- Self-hosting in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)) and full mutual cross-generation (Haskell ↔ Java ↔ Python).
+- New bootstrapping demo validating all 9 paths across 249 modules.
+- Promoted Haskell, Java, and Python coders from staging code into Hydra DSL sources ([#176](https://github.com/CategoricalData/hydra/issues/176)).
+- JSON-as-source-of-truth bootstrapping architecture ([#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)):
+  new executables and scripts enabling `bootstrap-from-json` for cross-implementation
+  code generation.
+- Generated term encoders and decoders replace legacy hand-coded modules ([#47](https://github.com/CategoricalData/hydra/issues/47)).
+- Hydra-Python completion ([#66](https://github.com/CategoricalData/hydra/issues/66)): restructured project layout with `src/main` and
+  `src/gen-main` ([#191](https://github.com/CategoricalData/hydra/issues/191)); full library implementations including `hydra.lib.flows`;
+  `@lru_cache` optimization for nullary bindings; PyPy compatibility.
+- Hydra-Java completion ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass; deep changes
+  to Java coder; `Lazy` utility class for delayed evaluation; array-type support
+  in Java serde; tail-call optimization in the Java coder; `Tuple` implements `Comparable`.
+- Either type ([#210](https://github.com/CategoricalData/hydra/issues/210)): `EitherType`, `either` term constructor, `hydra.lib.eithers` library
+  with `either`, `map`, `mapList`, `mapMaybe`, `bimap`, `bind`, `fromLeft`, `fromRight`,
+  `isLeft`, `isRight`, `lefts`, `rights`, `partitionEithers`.
+- Pair type as a core construct ([#211](https://github.com/CategoricalData/hydra/issues/211)).
+- Void type ([#237](https://github.com/CategoricalData/hydra/issues/237)): uninhabited `void` type as the dual of `unit`; type-level only.
+- Native JSON parser and writer ([#188](https://github.com/CategoricalData/hydra/issues/188), [#242](https://github.com/CategoricalData/hydra/issues/242)):
+  bidirectional JSON encoder/decoder; replaces the Aeson dependency;
+  cross-checked via a special test runner.
+- Typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)):
+  type schemes with typeclass constraints via `TypeVariableMetadata`;
+  typeclass metadata on primitive definitions; Haskell coder uses typeclass info.
+- Binary/`ByteString` support ([#172](https://github.com/CategoricalData/hydra/issues/172)): binary data via `ByteString` instead of `String`;
+  Haskell coder uses `Data.ByteString`; new `binaryToBytes` primitive.
+- Parser combinators: new `hydra.parsing` module with combinator types and DSL.
+- Higher-order primitive interpreter ([#198](https://github.com/CategoricalData/hydra/issues/198)): all primitives are fully interpretable
+  across all three implementations; legacy `requiresInterp` tag removed.
+- Let hoisting and flattening: hoisting polymorphic let terms;
+  refined hoisting for monomorphic bindings inside polymorphic ones;
+  more efficient `liftLambdaAboveLet` ([#202](https://github.com/CategoricalData/hydra/issues/202));
+  case-statement hoisting ([#241](https://github.com/CategoricalData/hydra/issues/241)); subterm hoisting helpers.
+- Provisional language targets: Go ([#65](https://github.com/CategoricalData/hydra/issues/65)), Rust (with experimental type-level coder),
+  JavaScript (syntax model, serde, DSL, generated sources), and Java/Python syntax DSLs.
+- New adapter framework ([#236](https://github.com/CategoricalData/hydra/issues/236)): all external coders refactored
+  (Haskell, YAML, Scala, JSON Schema, C++, PDL, Protobuf, GraphQL).
+- Compact labeled records and variants ([#122](https://github.com/CategoricalData/hydra/issues/122)).
+- New primitives:
+  `hydra.lib.lists.find`, `hydra.lib.lists.partition`,
+  `hydra.lib.flows.withDefault`, `hydra.lib.flows.foldl`,
+  `hydra.lib.math.{max,min,abs,pred,signum,succ,even,odd}`,
+  `hydra.lib.pairs.bimap`, `hydra.lib.eithers.bind`,
+  `hydra.lib.literals.binaryToBytes`, complete `readXxx`/`showXxx` families,
+  `hydra.lexical.chooseUniqueName`, `neg` renamed to `negate`,
+  full floating-point math primitives in Python ([#208](https://github.com/CategoricalData/hydra/issues/208)).
+- DeepCore DSL: a layer one level deeper than the Meta DSLs,
+  for programs that construct programs that construct terms.
+- `typeOf` implementation ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+- Implement `Comparable` for generated Java classes ([#131](https://github.com/CategoricalData/hydra/issues/131)); update of Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)).
+- Compact labeled records exploration ([#122](https://github.com/CategoricalData/hydra/issues/122)).
+- Comparison primitives without typeclasses ([#187](https://github.com/CategoricalData/hydra/issues/187)).
+- Investigated core support for Either and Flow monads ([#200](https://github.com/CategoricalData/hydra/issues/200)).
+
+### Improvements
+
+- Type system:
+  - Refactored `hydra.inference` to create new module `hydra.checking`.
+  - Inference checks after unification to prevent schema names from being unified
+    with inferred type variables.
+  - Type application terms preserved when preparing application terms for Python.
+  - Sanity-check tuple projection index against arity during inference.
+  - Bind lost type variables in term annotations.
+  - Made `extendTypeContextForLet` tolerant of untyped bindings.
+- Code generation:
+  - Python: support for deeply-nested match statements; more complete `let` support;
+    Pythonic syntax for polymorphic function definitions; refinements for complex
+    case-hoisting scenarios; performance improvements ([#209](https://github.com/CategoricalData/hydra/issues/209), [#239](https://github.com/CategoricalData/hydra/issues/239), [#240](https://github.com/CategoricalData/hydra/issues/240)); inline
+    let/case rewriting for Python targets ([#203](https://github.com/CategoricalData/hydra/issues/203)).
+  - Java: method declaration style consistent with calling style.
+  - Haskell: standardized typeclass names.
+  - Increased maximum trace depth to support more complex sources.
+- Common test suite promotion: all tests promoted into a shared, implementation-independent
+  test kernel ([#213](https://github.com/CategoricalData/hydra/issues/213)).
+- Statically-compiled test suite in Haskell ([#207](https://github.com/CategoricalData/hydra/issues/207)).
+- Included all Hydra kernel types in test schema ([#205](https://github.com/CategoricalData/hydra/issues/205)).
+- Reorganized Haskell DSL definitions; standardized imports.
+- Added TODO comments to all unsafe primitives ([#201](https://github.com/CategoricalData/hydra/issues/201)).
+- New `rewriteAndFoldTerm` utility for simultaneous rewriting and folding.
+- Lexical helper for dereferencing schema types through aliases.
+- Made JSON parser lazy with new `lazy` parser combinator.
+- More efficient substitution helpers for empty substitutions.
+- Precomputed type/inference context in kernel test runner for performance.
+- Property graph encoding and decoding modules promoted into DSL.
+- `hydra.tabular` and `hydra.pg.graphson` modules promoted into DSL.
+- `hydra.show.*` modules generated into Java and Python.
+- Aligned epsilon encoding with the LambdaGraph spec ([#89](https://github.com/CategoricalData/hydra/issues/89)).
+- Fixed asymmetry of introductions and eliminations ([#86](https://github.com/CategoricalData/hydra/issues/86), [#134](https://github.com/CategoricalData/hydra/issues/134)).
+- Minimized inferred type annotations ([#114](https://github.com/CategoricalData/hydra/issues/114)).
+- Investigated combining products with records, sums with unions ([#196](https://github.com/CategoricalData/hydra/issues/196), [#212](https://github.com/CategoricalData/hydra/issues/212)).
+- Refined type reduction in adapters ([#144](https://github.com/CategoricalData/hydra/issues/144)).
+- Investigation of unification issues ([#163](https://github.com/CategoricalData/hydra/issues/163)).
+- Refactored RowType ([#82](https://github.com/CategoricalData/hydra/issues/82)).
+- LLM-assisted PG schemas and mappings ([#171](https://github.com/CategoricalData/hydra/issues/171)).
+- Simplified unit-valued variants in Python ([#206](https://github.com/CategoricalData/hydra/issues/206)).
+- Checked for inconsistencies between Term/TTerm and Type/TType DSLs ([#218](https://github.com/CategoricalData/hydra/issues/218)).
+- GenPG demo: refactored to support Haskell, Python, and Java; Python runner;
+  Java generation; finalized output format.
+- Testing: extended test runners for let hoisting (Haskell, Python, Java);
+  floating-point precision tests; ordering tests for `hydra.lib.maps`/`hydra.lib.sets`;
+  inference tests for inferred System F terms; case-hoisting test cases; new JSON coder tests;
+  thorough test cases for all primitives ([#199](https://github.com/CategoricalData/hydra/issues/199)).
+
+### Bug fixes
+
+- Fixed interpreter bugs causing test failures ([#235](https://github.com/CategoricalData/hydra/issues/235)).
+- Fixed bug in type checking in connection with dead code.
+- Fixed bug in `removeTypesFromTerm`.
+- Fixed bug in `typeOfMap`.
+- Fixed 32-bit max int value in `hydra.constants`.
+- Fixed numeric precision in Python.
+- Added `BigDecimal` support and fixed `uint8` (short) support in Java.
+- Fixed Haskell coder with respect to imports for binary literals.
+- Excluded `Prelude.encodeFloat` and `Prelude.decodeFloat` from generated Haskell
+  due to name collisions.
+- Fixed consistency issues in Python primitives:
+  `hydra.lib.sets.toList`, `hydra.lib.maps.union` (precedence),
+  `hydra.lib.strings.lines`, `hydra.lib.strings.readString` (dequoting),
+  `hydra.lib.lists.apply`, `hydra.lib.maps.toList`.
+- Fixed Haskell type signature of `hydra.lists.span`.
+- Fixed issue with eta expansion of typed terms.
+- Fixed shadowing issue in generated encoding modules.
+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.
+
+### Documentation
+
+- Updated main README with complete implementation status.
+- Added Documentation sections to all implementation READMEs.
+- Fixed outdated Code-organization.md (Python now uses `src/gen-main`).
+- Fixed incorrect code paths in Implementation.md.
+- Added Java section to Testing wiki.
+- Comprehensive developer recipes in `docs/recipes/`.
+- Documentation for tail-call optimization implementation.
+- Added Haddock comments to Haskell primitives.
+- Created wiki page on the release process ([#194](https://github.com/CategoricalData/hydra/issues/194)).
+
+### Community
+
+- Accepted babeloff's `isTrivialTerm` changes.
+
+---
+
+## [0.12.0] - 2025-08-28
+
+A consolidation release: significant Python progress, kernel-level cleanup,
+and a wave of bookkeeping closures for Hydra-Java module ports.
+
+### Breaking changes
+
+- Removed `hydra.decoding` module ([#190](https://github.com/CategoricalData/hydra/issues/190)).
+- Flattened dependency tiers; eliminated tier-1, tier-2, tier-3 organization ([#184](https://github.com/CategoricalData/hydra/issues/184)).
+- Removed `typed` term variant ([#173](https://github.com/CategoricalData/hydra/issues/173), [#162](https://github.com/CategoricalData/hydra/issues/162)).
+- Module naming changes: moved tabular and relational modules into kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).
+- Standardized on uncurried helper functions in term-level DSLs ([#174](https://github.com/CategoricalData/hydra/issues/174)).
+- Renamed `hydra.lib.flows.traverseOptional` to `hydra.lib.flows.mapOptional`.
+- Eliminated camel-cased namespace parts from the kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).
+- Replaced list and optional eliminations with primitive functions ([#150](https://github.com/CategoricalData/hydra/issues/150)).
+- Moved `Hydra.Ext` to hydra-ext ([#178](https://github.com/CategoricalData/hydra/issues/178)); moved 'ext' sources into hydra-ext ([#189](https://github.com/CategoricalData/hydra/issues/189)).
+
+### New features
+
+- Significant progress toward Hydra-Python completion:
+  generated all kernel types and terms into Python;
+  added `Decimal` support for bigfloat values;
+  environment tracking for variable scoping;
+  generated `hydra.languages` into Python;
+  `__hash__` and `__eq__` on serializable generated classes ([#160](https://github.com/CategoricalData/hydra/issues/160)).
+- Designated `unit` term and type variants ([#186](https://github.com/CategoricalData/hydra/issues/186)).
+- `hydra.lib.flows.mapElems` and `hydra.lib.flows.mapKeys` utilities.
+- Promoted JSON coder into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).
+- Promoted JSON utilities into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).
+- C# coder ([#139](https://github.com/CategoricalData/hydra/issues/139)).
+- GQL model and parser ([#140](https://github.com/CategoricalData/hydra/issues/140)).
+- Tabular adapters ([#142](https://github.com/CategoricalData/hydra/issues/142)).
+- Type-level C++ coder ([#170](https://github.com/CategoricalData/hydra/issues/170)).
+- Variable-types-to-Haskell-typedefs transformation ([#70](https://github.com/CategoricalData/hydra/issues/70)).
+- A newline at the end of each generated file ([#154](https://github.com/CategoricalData/hydra/issues/154)).
+- Refactor kernel modules and primitives by connectivity ([#177](https://github.com/CategoricalData/hydra/issues/177)).
+
+### Improvements
+
+- Condensed repeated elements in error traces ([#165](https://github.com/CategoricalData/hydra/issues/165)).
+- Fixed transitive schema dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).
+- Improved adapter solution with respect to literals.
+- Better handling of type variables in Python coder.
+- Enhanced term-level Python generation with proper ordering to minimize forward references.
+- Topo-sort helper function for dependency management.
+- Updated all Python libraries with latest changes.
+- Distinguished between deannotation and detyping of terms.
+- Adapted primitives when applying language constraints to a graph.
+- Use unqualified names where possible in generated code ([#153](https://github.com/CategoricalData/hydra/issues/153)).
+- Eliminated `Data.Graph` (containers) dependency ([#167](https://github.com/CategoricalData/hydra/issues/167)).
+- "Close the loop" demonstration ([#175](https://github.com/CategoricalData/hydra/issues/175)).
+- Implemented `typeOf` ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+
+### Bug fixes
+
+- Fixed System F terms for records and case statements ([#168](https://github.com/CategoricalData/hydra/issues/168)).
+- Fixed issue with transitive type-level module dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).
+- Corrected handling of variable references in Python application terms.
+- Fixed nullary functions in Python (added empty parens).
+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.
+
+### Bookkeeping
+
+- Closed long-standing Hydra-Java module-port issues
+  ([#9](https://github.com/CategoricalData/hydra/issues/9), [#11](https://github.com/CategoricalData/hydra/issues/11), [#15](https://github.com/CategoricalData/hydra/issues/15), [#16](https://github.com/CategoricalData/hydra/issues/16), [#18](https://github.com/CategoricalData/hydra/issues/18), [#19](https://github.com/CategoricalData/hydra/issues/19), [#20](https://github.com/CategoricalData/hydra/issues/20), [#21](https://github.com/CategoricalData/hydra/issues/21), [#22](https://github.com/CategoricalData/hydra/issues/22), [#23](https://github.com/CategoricalData/hydra/issues/23), [#25](https://github.com/CategoricalData/hydra/issues/25), [#44](https://github.com/CategoricalData/hydra/issues/44), [#45](https://github.com/CategoricalData/hydra/issues/45));
+  most of the underlying work shipped in earlier releases.
+- Closed Hydra-Java DSL-port issues ([#24](https://github.com/CategoricalData/hydra/issues/24), [#26](https://github.com/CategoricalData/hydra/issues/26), [#27](https://github.com/CategoricalData/hydra/issues/27), [#28](https://github.com/CategoricalData/hydra/issues/28), [#29](https://github.com/CategoricalData/hydra/issues/29)) and
+  the Scala/Avro tracking issues ([#77](https://github.com/CategoricalData/hydra/issues/77), [#81](https://github.com/CategoricalData/hydra/issues/81)); these had been resolved
+  by earlier releases (Scala in 0.14.0, Avro bidi in 0.14.0).
+
+### Documentation
+
+- Updated Hydra-Haskell README.
+- Updated Hydra-Java README with corrected links.
+- Updated JavaDocs.
+
+---
+
+## [0.11.0] - 2025-03-16
+
+Untagged in-repository version.
+A type-inference rebase release: major restructuring of inference internals
+to align with Algorithm W, plus a sweeping removal of explicit type annotations
+across the kernel.
+
+### Highlights
+
+- **Inference rebased on Algorithm W** ([#118](https://github.com/CategoricalData/hydra/issues/118)): unify-early strategy ([#146](https://github.com/CategoricalData/hydra/issues/146)),
+  infinite-type checks restored ([#116](https://github.com/CategoricalData/hydra/issues/116)), recursive-element inference ([#90](https://github.com/CategoricalData/hydra/issues/90)),
+  unified handling of elements and let bindings ([#112](https://github.com/CategoricalData/hydra/issues/112)), minimized manual
+  type annotations ([#119](https://github.com/CategoricalData/hydra/issues/119)).
+- **`hydra.inference` module** introduced for inference type definitions;
+  substitution and unification moved up a level.
+
+### Breaking changes
+
+- Argument order of `Logic.ifElse` changed ([#147](https://github.com/CategoricalData/hydra/issues/147)).
+
+### New features
+
+- Inference test cases promoted into the common test suite ([#148](https://github.com/CategoricalData/hydra/issues/148));
+  added "kernel examples" inference tests; more recursion / mutual recursion cases.
+
+### Improvements
+
+- Removed type annotations across all kernel sources ([#119](https://github.com/CategoricalData/hydra/issues/119)).
+- Migrated to fully-applied primitive library DSLs ([#157](https://github.com/CategoricalData/hydra/issues/157)).
+- Aligned `Graph` and `Element` with `LetBinding` ([#159](https://github.com/CategoricalData/hydra/issues/159)).
+- `hydra.core.Unit` recognized by the Haskell coder.
+- Refactored inference tests.
+
+### Bug fixes
+
+- Fix for underdetermined type in `hydra.decode`.
+
+---
+
+## [0.10.0] - 2025-02-19
+
+Untagged in-repository version.
+Adds Hydra-Python (initial completion), a GraphSON coder,
+provisional Hydra-Go support, and dot-separated namespace conventions.
+
+### Highlights
+
+- **Hydra-Python initial completion** ([#80](https://github.com/CategoricalData/hydra/issues/80), [#66](https://github.com/CategoricalData/hydra/issues/66)): Python coder, generated kernel
+  modules in Python, and full library implementations across kernel namespaces.
+- **GraphSON coder** ([#79](https://github.com/CategoricalData/hydra/issues/79)).
+- **Provisional Hydra-Go** ([#65](https://github.com/CategoricalData/hydra/issues/65)).
+- **Namespace formatting** standardized to dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).
+
+### Breaking changes
+
+- All namespaces use dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).
+
+### New features
+
+- Hydra-Python: Python coder; generated `hydra.coreEncoding`, `hydra.strip`,
+  `hydra.literals` and other kernel modules in Python; tuple-expression support;
+  updated `hydra.constants` in Python.
+- GraphSON coder ([#79](https://github.com/CategoricalData/hydra/issues/79)).
+- Provisional Hydra-Go ([#65](https://github.com/CategoricalData/hydra/issues/65)).
+- `string-to-char-list` and `char-list-to-string` primitives ([#149](https://github.com/CategoricalData/hydra/issues/149)).
+- Restored normalization for generated term variables ([#145](https://github.com/CategoricalData/hydra/issues/145)).
+
+### Improvements
+
+- Re-leveled dependency tiers ([#135](https://github.com/CategoricalData/hydra/issues/135)).
+- Updated all Java, Haskell, hydra-ext, and Python primitives to current sources.
+
+---
+
+## [0.9.0] - 2025-01-06
+
+Untagged in-repository version.
+Bootstraps Hydra-Python and the JSON Schema coder; introduces a fluent Java DSL for flows.
+
+### Highlights
+
+- **JSON Schema coder** ([#141](https://github.com/CategoricalData/hydra/issues/141)).
+- **Python coder scaffold**: serde, language constraints, and generated Haskell
+  sources for Python.
+- **Fluent-style Java DSL for flows** ([#143](https://github.com/CategoricalData/hydra/issues/143)).
+
+### New features
+
+- JSON Schema coder ([#141](https://github.com/CategoricalData/hydra/issues/141)).
+- Python coder scaffold and serde.
+- Provisional Python language constraints module.
+- Fluent-style Java DSL for flows ([#143](https://github.com/CategoricalData/hydra/issues/143)); moved Flows DSL into `hydra.dsl`.
+- New `hydra.coders` DSL.
+- New DSL functions for core variants.
+
+### Improvements
+
+- Generalized `Namespaces` so it can be used for languages other than Haskell.
+- Local-name-only Python type aliases (the directory tree provides the namespace).
+- Coders DSL used to simplify Java language-constraint sources.
+- Removed redundant productions in the Python grammar.
+- Added unit tests for fluent flows.
+
+### Documentation
+
+- Updated JavaDocs for 0.9.0.
+
+---
+
+## [0.8.1] - 2024-09-24
+
+Patch release.
+
+### Improvements
+
+- Generalized the property graph merging utility to accept type systems other than Hydra Core.
+
+---
+
+## [0.8.0] - 2024-09-09
+
+C# support ([#139](https://github.com/CategoricalData/hydra/issues/139)), Graphviz DOT coder, term accessors, and a small breaking change in Java
+to support Spark.
+
+### Breaking changes
+
+- Made `FlowException` serializable for Spark support (may affect existing error handling).
+
+### New features
+
+- C# syntax module based on the Microsoft ANTLR grammar ([#139](https://github.com/CategoricalData/hydra/issues/139)).
+- Graphviz DOT coder ([#136](https://github.com/CategoricalData/hydra/issues/136)):
+  full support for lambdas and recursive `let` statements;
+  compact 'accessor graph' visualization option;
+  customizable label styles;
+  highlighted let-bound terms; edge labels.
+- Term accessor type to facilitate lenses and path-aware transformations.
+- OpenGQL grammar and generated Haskell for the OpenGQL model ([#140](https://github.com/CategoricalData/hydra/issues/140)).
+
+### Improvements
+
+- Added `</>` as alternative to `@@` application operator in Haskell DSLs.
+- Utilities for working with term accessors.
+- More specific exception class for JSON decoding.
+- Additional convenience methods on `JsonDecoding.java`.
+- Used transitive dependencies in hydra-java and hydra-ext.
+- Upgraded ANTLR to address a vulnerability.
+- Moved TinkerPop utilities from `hydra/ext/org/apache/tinkerpop` into `hydra/pg`.
+
+---
+
+## [0.7.0] - 2024-08-21
+
+Major refactoring of module organization and namespace management.
+Establishes the DNS-style namespace convention in hydra-ext
+and lifts property-graph models into a top-level `hydra/pg` namespace.
+
+### Breaking changes
+
+- Namespace reorganization: migrated to DNS-based module naming in hydra-ext ([#138](https://github.com/CategoricalData/hydra/issues/138)):
+  `hydra/ext/avro` → `hydra/ext/org/apache/avro`,
+  `hydra/ext/graphql` → `hydra/ext/org/graphql`,
+  `hydra/ext/yaml` → `hydra/ext/org/yaml`,
+  `hydra/ext/json/decoding` → `hydra/ext/org/json/decoding`,
+  `hydra/ext/rdf` → `hydra/ext/org/w3/rdf`,
+  `hydra/ext/shacl` → `hydra/ext/org/w3/shacl`,
+  `hydra/ext/tinkerpop` → `hydra/ext/org/apache/tinkerpop`.
+- Property graphs: promoted property graph modules from
+  `hydra/ext/org/apache/tinkerpop` to `hydra/pg`.
+- Project structure: renamed `hydra-extensions` to `hydra-ext`;
+  renamed `hydra/langs` to `hydra/ext` ([#138](https://github.com/CategoricalData/hydra/issues/138));
+  made hydra-ext into a Gradle subproject alongside hydra-java;
+  added top-level Gradle build.
+
+### Improvements
+
+- Moved TinkerPop modules from hydra-haskell into hydra-ext for better separation.
+- Moved miscellaneous models to `Hydra.Ext.Other` ([#138](https://github.com/CategoricalData/hydra/issues/138)).
+- Moved XML Schema, SQL, ShEx, and OWL models to hydra-ext.
+- Moved KQL, Parquet, and Python modules to hydra-ext.
+- Separated JavaDocs for hydra-java and hydra-ext.
+- Updated publishing configuration in `build.gradle`.
+
+---
+
+## [0.6.0] - 2024-08-19
+
+Type-system improvements (System F type abstraction/application; eliminated polymorphic
+types from Hydra Core), expanded language support (Graphviz DOT model, generated Java
+field-name constants), and revamped annotation handling.
+
+### Breaking changes
+
+- Eliminated `InferenceContext` helper type ([#103](https://github.com/CategoricalData/hydra/issues/103)).
+- Changed typing environment from `Map Name Type` to `Map Name TypeScheme` in graphs ([#76](https://github.com/CategoricalData/hydra/issues/76)).
+- Updated annotations and flows to use `map<Name, Term>` instead of `map<string, Term>` ([#133](https://github.com/CategoricalData/hydra/issues/133)).
+- Unified `Name` and `FieldName`; aliased to `string` ([#121](https://github.com/CategoricalData/hydra/issues/121)).
+- Renamed `hydra/core.UnitType` to `hydra/core.Unit` ([#123](https://github.com/CategoricalData/hydra/issues/123)).
+- Eliminated annotation classes; Hydra has a single built-in notion of annotations ([#113](https://github.com/CategoricalData/hydra/issues/113)).
+- Unified the `Nominal` type with `RowType` ([#115](https://github.com/CategoricalData/hydra/issues/115)).
+- Removed the `extends` parameter for row types ([#132](https://github.com/CategoricalData/hydra/issues/132)).
+- Replaced `hydra/Kv` with `hydra/Annotations` (rename revisited).
+
+### New features
+
+- System F support: `typeAbstraction` and `typeApplication` term constructors.
+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).
+- Graphviz DOT model and initial support ([#136](https://github.com/CategoricalData/hydra/issues/136)).
+- Field-name constants generated in Java code generation ([#137](https://github.com/CategoricalData/hydra/issues/137)).
+- Provisional Algorithm W implementation in Haskell (originally from @wisnesky), kept for reference.
+
+### Improvements
+
+- Primitive organization: Hydra primitives organized into libraries for namespace management.
+- Code generation:
+  - Escaped field name constants and `with_` methods in Java coder.
+  - Generated field name constants in Java ([#137](https://github.com/CategoricalData/hydra/issues/137)).
+  - Avoided duplicated comments in wrapper classes in generated Java.
+  - Removed superfluous newtype comments in Haskell coder.
+- Updated Delta Parquet model to follow the Java API more closely.
+- Enriched OpenCypher features module with the complete list of standard Cypher functions.
+- Added convenience methods to `JsonEncoding.java`.
+- Restored `Hydra.Inference` subdirectory.
+- Allowed arbitrary case for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+- Corrected `uint8` representation in Java to `Short` ([#120](https://github.com/CategoricalData/hydra/issues/120)).
+
+### Bug fixes
+
+- Fixed handling of type annotations in term adapters.
+- Fixed decoding of encoded terms annotated with a type.
+- Corrected encoding of universal types in `showTerm` ([#117](https://github.com/CategoricalData/hydra/issues/117)).
+
+---
+
+## [0.5.3] - 2024-08-06
+
+Patch release.
+Preserves order of map key/value pairs and set elements during JSON serialization.
+
+### Bug fixes
+
+- Preserved ordering of key/value pairs and set elements in JSON output.
+
+### New features
+
+- Polymorphic `equal` primitive in Haskell and Java.
+- Generated Hydra type definitions together with native instantiations of Hydra types
+  in Haskell (a stepping stone toward generated coders, [#47](https://github.com/CategoricalData/hydra/issues/47)).
+
+---
+
+## [0.5.1] - 2024-08-01
+
+Patch release.
+Dependency updates and minor improvements following the 0.5.0 Hydra Core overhaul.
+
+### Improvements
+
+- Updated dependencies.
+
+---
+
+## [0.5.0] - 2024-07-26
+
+Untagged in-repository version.
+Major Hydra Core overhaul: eliminates polymorphic types in favor of explicit
+TypeScheme; consolidates the annotation system; revamps `Let` term encoding.
+
+### Breaking changes
+
+- Eliminated polymorphic types from Hydra Core in Haskell ([#125](https://github.com/CategoricalData/hydra/issues/125)):
+  removed type parameters from `hydra/core` types in Hydra-Java; replaced type schemes
+  with forall types ([#76](https://github.com/CategoricalData/hydra/issues/76)).
+- Revamped core encoding and `Let`: bindings are now a list of
+  `(name, term, optional type scheme)` triplets instead of a map.
+- Unified typed-term types and moved `TypeScheme` into Hydra Core.
+- Eliminated `AnnotationClass`; Hydra has a single built-in notion of annotations now ([#113](https://github.com/CategoricalData/hydra/issues/113)).
+- Renamed and refactored phantom-type wrappers ([#128](https://github.com/CategoricalData/hydra/issues/128)); removed deprecated `Reference`
+  type from `hydra/phantoms`.
+- Removed incomplete support for stream types and stream terms ([#88](https://github.com/CategoricalData/hydra/issues/88)).
+
+### New features
+
+- `LiteralTypes` DSL module so literals can be built independently of terms.
+- `Hydra.Minimal` module to facilitate collaboration on Hydra application prototypes.
+- `TypeConstraint` type added to the kernel.
+- `foldl` primitive in Haskell and Java; DSL uses `foldl` instead of the built-in
+  list elimination term by default.
+
+### Improvements
+
+- Improvements to Java and JSON coders; improved untyped JSON coder.
+- Pre-order and post-order term-traversal test cases added.
+- Refactored type inference tests.
+- Restored generated Java (Core through Tier 3) with only a few manual tweaks.
+- Element names allow arbitrary case ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+
+---
+
+## [0.4.0] - 2024-07-10
+
+Untagged in-repository version.
+Adds null checks to generated Java (breaking, but justified — Hydra-Java disallows nulls),
+the Gremlin model, and Protobuf annotation refinements.
+
+### Breaking changes
+
+- Null checks added to constructors and `withXXX()` methods in generated Java;
+  null values are no longer permitted in Hydra-Java.
+- Removed Java 8 restriction (raised minimum Java version).
+
+### New features
+
+- Gremlin model ([#127](https://github.com/CategoricalData/hydra/issues/127)); generated Haskell for Gremlin.
+- `hydra/lib/lists.safeHead` primitive in Haskell (necessary in Java due to eager evaluation).
+- Support for Protobuf `deprecated=true` annotation; non-string Protobuf options.
+- Java options in generated Protobuf.
+
+### Improvements
+
+- Used `java.util.Objects.requireNonNull` instead of a custom null check in generated Java.
+- Added 'automatically generated file' disclaimer to generated Java files.
+- Added autogen comments and null checks to (most) generated Java.
+- Added necessary schema-level dependencies for built-in modules.
+- Added null checks to the Flows DSL in Java.
+
+---
+
+## [0.3.0] - 2024-06-05
+
+Untagged in-repository version.
+Adds an OpenCypher parser based on an ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124)),
+a KQL (Kusto Query Language) model and serializer,
+a Delta Parquet model,
+and an early property graph queries model in the style of Cypher.
+
+### New features
+
+- OpenCypher parser based on the OpenCypher M23 ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124));
+  ANTLR added as a build dependency;
+  large Cypher test suite drawn from the Cypher Manual.
+- Cypher-to-PG-query transformer (Java; partially implemented).
+- Property graph queries DSL and generated property graph query classes in Java.
+- Property graph queries model (Cypher / future GQL style).
+- KQL (Kusto Query Language) initial model and basic serializer.
+- Delta Parquet model with generated sources.
+
+### Improvements
+
+- Java options and `deprecated=true` support in generated Protobuf.
+- Convenience methods in Java.
+
+---
+
+## [0.2.0] - 2024-01-10
+
+Hydra-Java 0.2.0 release.
+Significant Java tooling and DSL build-out, Protobuf bidirectional coder,
+Python3 syntax model ([#80](https://github.com/CategoricalData/hydra/issues/80)), property graph validation ([#100](https://github.com/CategoricalData/hydra/issues/100)),
+JSON bidirectional support in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)),
+OpenCypher initial model ([#108](https://github.com/CategoricalData/hydra/issues/108)),
+Cypher unification, and the start of the typed-DSL story in Haskell.
+
+### New features
+
+- Property graph validation: validator type, optionality on property types,
+  customizable id/property handling in the merging adapter, fine-tuned validation,
+  comprehensive unit tests in Java ([#100](https://github.com/CategoricalData/hydra/issues/100)).
+- Bidirectional JSON serialization/deserialization in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)).
+- Checkstyle configuration based on Google style guide ([#111](https://github.com/CategoricalData/hydra/issues/111)).
+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).
+- Initial OpenCypher model and parser scaffold ([#108](https://github.com/CategoricalData/hydra/issues/108)).
+- Protobuf coder ([#99](https://github.com/CategoricalData/hydra/issues/99)): type encoder, field numbering, formatting, deprecated annotation,
+  Java options, non-string options.
+- Adapter framework tolerance of recursive types ([#58](https://github.com/CategoricalData/hydra/issues/58)); default branch for case
+  statements ([#60](https://github.com/CategoricalData/hydra/issues/60)).
+- Topological sort in type inference ([#67](https://github.com/CategoricalData/hydra/issues/67)).
+- `hydra/query` model ([#73](https://github.com/CategoricalData/hydra/issues/73)).
+- Records-to-TinkerPop-elements coder ([#64](https://github.com/CategoricalData/hydra/issues/64)).
+- Equality primitives for all literal types ([#92](https://github.com/CategoricalData/hydra/issues/92)); polymorphic logic primitives ([#95](https://github.com/CategoricalData/hydra/issues/95)).
+- `mapKeys` primitive ([#93](https://github.com/CategoricalData/hydra/issues/93)).
+- Tuple support in Java ([#94](https://github.com/CategoricalData/hydra/issues/94)).
+- Java 8 as an optional target ([#96](https://github.com/CategoricalData/hydra/issues/96)); optionally generate Java classes as `Serializable` ([#97](https://github.com/CategoricalData/hydra/issues/97)).
+- Bidirectional "merged vertex" and "merged edge" coders ([#106](https://github.com/CategoricalData/hydra/issues/106)).
+- Nullability and parameterization in the tabular model ([#107](https://github.com/CategoricalData/hydra/issues/107)).
+- Term-level / type-level dependency distinction for modules ([#109](https://github.com/CategoricalData/hydra/issues/109)).
+- Flatten nested `let` terms for transformation into Java ([#110](https://github.com/CategoricalData/hydra/issues/110)).
+- Various `Flow` utilities in Java: `bind3`; convenience methods for consuming results;
+  `fromFlow` variants including one that throws.
+
+### Improvements
+
+- Hydra-Java module ports ([#10](https://github.com/CategoricalData/hydra/issues/10), [#12](https://github.com/CategoricalData/hydra/issues/12), [#13](https://github.com/CategoricalData/hydra/issues/13), [#14](https://github.com/CategoricalData/hydra/issues/14), [#17](https://github.com/CategoricalData/hydra/issues/17), [#30](https://github.com/CategoricalData/hydra/issues/30), [#31](https://github.com/CategoricalData/hydra/issues/31), [#32](https://github.com/CategoricalData/hydra/issues/32), [#33](https://github.com/CategoricalData/hydra/issues/33), [#34](https://github.com/CategoricalData/hydra/issues/34), [#35](https://github.com/CategoricalData/hydra/issues/35),
+  [#38](https://github.com/CategoricalData/hydra/issues/38), [#39](https://github.com/CategoricalData/hydra/issues/39), [#41](https://github.com/CategoricalData/hydra/issues/41), [#43](https://github.com/CategoricalData/hydra/issues/43), [#48](https://github.com/CategoricalData/hydra/issues/48), [#71](https://github.com/CategoricalData/hydra/issues/71), [#72](https://github.com/CategoricalData/hydra/issues/72), [#75](https://github.com/CategoricalData/hydra/issues/75), [#83](https://github.com/CategoricalData/hydra/issues/83)):
+  `Common`, `CoreEncoding`, `CoreLanguage`, `Kernel`, `Flows`, `Lists`, `Literals`,
+  `Math`, `Sets`, `Strings`, `Optionals`, `Maps`, `Flows` primitives, `Sets` primitives.
+- Common DSLs in Haskell: Flow support ([#68](https://github.com/CategoricalData/hydra/issues/68)), Let support ([#69](https://github.com/CategoricalData/hydra/issues/69)).
+- Renamed annotation type parameter `m` to `a` ([#41](https://github.com/CategoricalData/hydra/issues/41)).
+- Updated wrapper, element, and variable types ([#75](https://github.com/CategoricalData/hydra/issues/75)).
+- Removed `schema` field from `Element` ([#83](https://github.com/CategoricalData/hydra/issues/83)).
+- GraphQL coder ([#78](https://github.com/CategoricalData/hydra/issues/78)).
+- Code quality:
+  - Updated main and test sources to conform to Checkstyle configuration ([#111](https://github.com/CategoricalData/hydra/issues/111)).
+  - Extended line-length limit from 100 to 120 characters.
+  - Disabled overly restrictive indentation and import-order rules.
+  - Disabled `RightCurlyAlone` for compact inline map definitions.
+- Streamlined property-graph element merging to unify properties with identical
+  keys and types ([#106](https://github.com/CategoricalData/hydra/issues/106)).
+- Convenience functions for printing literals and literal types in the Java DSL.
+- Minor addition to JSON decoding.
+- DSL convenience: alphabetic-case flexibility for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).
+
+### Bug fixes
+
+- Fixed type annotations for the Sets Java port ([#48](https://github.com/CategoricalData/hydra/issues/48)).
+- Various minor fixes during the Java module ports.
+
+---
+
+## [0.1.1] - 2022-12-04
+
+Patch release the same day as 0.1.0.
+README polish only.
+
+---
+
+## [0.1.0] - 2022-12-04
+
+First packaged release of Hydra (Hackage).
+This release contains the complete foundation of Hydra.
+
+### Core language
+
+- Hydra's core type and data languages (`hydra.core`).
+- Core models for graphs and modules.
+- Computation model with the `Flow` monad.
+- BNF grammars support.
+- Phantom types.
+- Basic operations on types and terms.
+
+### Type system
+
+- Hindley–Milner-style type inference.
+- Type schemes with polymorphism.
+- Type/term validation.
+
+### Transformations
+
+- Adapter system: type-to-type rewriting and transformation.
+- Coders:
+  Haskell coder (types and terms),
+  Java coder (types and terms),
+  partial Scala coder (terms only),
+  Avro coder,
+  JSON coder,
+  PDL (Pegasus Data Language) coder,
+  RDF + SHACL coder,
+  YAML coder.
+
+### Language support
+
+- Models for GraphQL, OWL (Web Ontology Language), ShEx (Shape Expressions),
+  and TinkerPop-style property graphs.
+
+### Developer tools
+
+- Type-construction DSL and term-construction DSL.
+- QuickCheck property-based tests.
+
+### Implementations
+
+- Hydra-Haskell: bootstrapping implementation with full kernel.
+- Hydra-Java: Java implementation with mature tooling.
+
+### Community
+
+- Set up the LambdaGraph Discord server ([#2](https://github.com/CategoricalData/hydra/issues/2)).
+
+---
+
+## Contributing
+
+We welcome contributions! Please see:
+
+- [Developer recipes](https://github.com/CategoricalData/hydra/tree/main/docs/recipes)
+- [LambdaGraph Discord](https://bit.ly/lg-discord)
+
+## Release process
+
+See the [Release policy](https://github.com/CategoricalData/hydra/wiki/Release-policy)
+wiki page and [docs/release-workflow.md](docs/release-workflow.md)
+for information on how Hydra releases are versioned, built, and published.
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/NOTICE b/NOTICE
new file mode 100644
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,3 @@
+Hydra
+Copyright 2021-2026 The Hydra authors
+https://github.com/CategoricalData/hydra
diff --git a/hydra-lisp.cabal b/hydra-lisp.cabal
new file mode 100644
--- /dev/null
+++ b/hydra-lisp.cabal
@@ -0,0 +1,44 @@
+cabal-version: 1.12
+
+-- This file has been generated from package.yaml by hpack version 0.39.1.
+--
+-- see: https://github.com/sol/hpack
+
+name:           hydra-lisp
+version:        0.17.0
+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
+homepage:       https://github.com/CategoricalData/hydra#readme
+bug-reports:    https://github.com/CategoricalData/hydra/issues
+author:         Joshua Shinavier <josh@fortytwo.net>
+maintainer:     Joshua Shinavier <josh@fortytwo.net>
+license:        Apache-2.0
+license-file:   LICENSE
+build-type:     Simple
+extra-source-files:
+    LICENSE
+    NOTICE
+    CHANGELOG.md
+
+source-repository head
+  type: git
+  location: https://github.com/CategoricalData/hydra
+
+library
+  exposed-modules:
+      Hydra.Dsl.Lisp.Syntax
+      Hydra.Lisp.Coder
+      Hydra.Lisp.Language
+      Hydra.Lisp.Serde
+      Hydra.Lisp.Syntax
+  other-modules:
+      Paths_hydra_lisp
+  hs-source-dirs:
+      src/main/haskell
+  build-depends:
+      base >=4.19.0 && <4.22
+    , containers >=0.6.7 && <0.8
+    , hydra-kernel ==0.17.0
+    , scientific >=0.3.7 && <0.4
+  default-language: Haskell2010
diff --git a/src/main/haskell/Hydra/Dsl/Lisp/Syntax.hs b/src/main/haskell/Hydra/Dsl/Lisp/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Dsl/Lisp/Syntax.hs
@@ -0,0 +1,4521 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | DSL functions for hydra.lisp.syntax
+
+module Hydra.Dsl.Lisp.Syntax where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.Dsl.Core as DslCore
+import qualified Hydra.Lisp.Syntax as Syntax
+import qualified Hydra.Typed as Typed
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+-- | DSL constructor for hydra.lisp.syntax.AndExpression
+andExpression :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.AndExpression
+andExpression expressions =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.AndExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm expressions)}]}))
+
+-- | DSL accessor for the expressions field of hydra.lisp.syntax.AndExpression
+andExpressionExpressions :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm [Syntax.Expression]
+andExpressionExpressions x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.AndExpression"),
+        Core.projectionFieldName = (Core.Name "expressions")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expressions field of hydra.lisp.syntax.AndExpression
+andExpressionWithExpressions :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.AndExpression
+andExpressionWithExpressions original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.AndExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.Application
+application :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Application
+application function arguments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Application"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "function"),
+          Core.fieldTerm = (Typed.unTypedTerm function)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm arguments)}]}))
+
+-- | DSL accessor for the arguments field of hydra.lisp.syntax.Application
+applicationArguments :: Typed.TypedTerm Syntax.Application -> Typed.TypedTerm [Syntax.Expression]
+applicationArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Application"),
+        Core.projectionFieldName = (Core.Name "arguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the function field of hydra.lisp.syntax.Application
+applicationFunction :: Typed.TypedTerm Syntax.Application -> Typed.TypedTerm Syntax.Expression
+applicationFunction x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Application"),
+        Core.projectionFieldName = (Core.Name "function")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the arguments field of hydra.lisp.syntax.Application
+applicationWithArguments :: Typed.TypedTerm Syntax.Application -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Application
+applicationWithArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Application"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "function"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Application"),
+              Core.projectionFieldName = (Core.Name "function")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the function field of hydra.lisp.syntax.Application
+applicationWithFunction :: Typed.TypedTerm Syntax.Application -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Application
+applicationWithFunction original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Application"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "function"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Application"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.BeginExpression
+beginExpression :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.BeginExpression
+beginExpression expressions =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.BeginExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm expressions)}]}))
+
+-- | DSL accessor for the expressions field of hydra.lisp.syntax.BeginExpression
+beginExpressionExpressions :: Typed.TypedTerm Syntax.BeginExpression -> Typed.TypedTerm [Syntax.Expression]
+beginExpressionExpressions x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.BeginExpression"),
+        Core.projectionFieldName = (Core.Name "expressions")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expressions field of hydra.lisp.syntax.BeginExpression
+beginExpressionWithExpressions :: Typed.TypedTerm Syntax.BeginExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.BeginExpression
+beginExpressionWithExpressions original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.BeginExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the hashTF variant of hydra.lisp.syntax.BooleanStyle
+booleanStyleHashTF :: Typed.TypedTerm Syntax.BooleanStyle
+booleanStyleHashTF =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.BooleanStyle"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "hashTF"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the tNil variant of hydra.lisp.syntax.BooleanStyle
+booleanStyleTNil :: Typed.TypedTerm Syntax.BooleanStyle
+booleanStyleTNil =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.BooleanStyle"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "tNil"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the trueFalse variant of hydra.lisp.syntax.BooleanStyle
+booleanStyleTrueFalse :: Typed.TypedTerm Syntax.BooleanStyle
+booleanStyleTrueFalse =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.BooleanStyle"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "trueFalse"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.lisp.syntax.CaseClause
+caseClause :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CaseClause
+caseClause keys body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "keys"),
+          Core.fieldTerm = (Typed.unTypedTerm keys)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.CaseClause
+caseClauseBody :: Typed.TypedTerm Syntax.CaseClause -> Typed.TypedTerm Syntax.Expression
+caseClauseBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseClause"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the keys field of hydra.lisp.syntax.CaseClause
+caseClauseKeys :: Typed.TypedTerm Syntax.CaseClause -> Typed.TypedTerm [Syntax.Expression]
+caseClauseKeys x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseClause"),
+        Core.projectionFieldName = (Core.Name "keys")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.lisp.syntax.CaseClause
+caseClauseWithBody :: Typed.TypedTerm Syntax.CaseClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CaseClause
+caseClauseWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "keys"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseClause"),
+              Core.projectionFieldName = (Core.Name "keys")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the keys field of hydra.lisp.syntax.CaseClause
+caseClauseWithKeys :: Typed.TypedTerm Syntax.CaseClause -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.CaseClause
+caseClauseWithKeys original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "keys"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseClause"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.CaseExpression
+caseExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.CaseClause] -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.CaseExpression
+caseExpression scrutinee clauses default_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "scrutinee"),
+          Core.fieldTerm = (Typed.unTypedTerm scrutinee)},
+        Core.Field {
+          Core.fieldName = (Core.Name "clauses"),
+          Core.fieldTerm = (Typed.unTypedTerm clauses)},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))
+
+-- | DSL accessor for the clauses field of hydra.lisp.syntax.CaseExpression
+caseExpressionClauses :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm [Syntax.CaseClause]
+caseExpressionClauses x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+        Core.projectionFieldName = (Core.Name "clauses")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the default field of hydra.lisp.syntax.CaseExpression
+caseExpressionDefault :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm (Maybe Syntax.Expression)
+caseExpressionDefault x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+        Core.projectionFieldName = (Core.Name "default")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the scrutinee field of hydra.lisp.syntax.CaseExpression
+caseExpressionScrutinee :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm Syntax.Expression
+caseExpressionScrutinee x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+        Core.projectionFieldName = (Core.Name "scrutinee")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the clauses field of hydra.lisp.syntax.CaseExpression
+caseExpressionWithClauses :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm [Syntax.CaseClause] -> Typed.TypedTerm Syntax.CaseExpression
+caseExpressionWithClauses original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "scrutinee"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+              Core.projectionFieldName = (Core.Name "scrutinee")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "clauses"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the default field of hydra.lisp.syntax.CaseExpression
+caseExpressionWithDefault :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.CaseExpression
+caseExpressionWithDefault original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "scrutinee"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+              Core.projectionFieldName = (Core.Name "scrutinee")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "clauses"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+              Core.projectionFieldName = (Core.Name "clauses")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the scrutinee field of hydra.lisp.syntax.CaseExpression
+caseExpressionWithScrutinee :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CaseExpression
+caseExpressionWithScrutinee original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "scrutinee"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "clauses"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+              Core.projectionFieldName = (Core.Name "clauses")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CaseExpression"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.CharacterLiteral
+characterLiteral :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.CharacterLiteral
+characterLiteral value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CharacterLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.CharacterLiteral
+characterLiteralValue :: Typed.TypedTerm Syntax.CharacterLiteral -> Typed.TypedTerm String
+characterLiteralValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CharacterLiteral"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.CharacterLiteral
+characterLiteralWithValue :: Typed.TypedTerm Syntax.CharacterLiteral -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.CharacterLiteral
+characterLiteralWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CharacterLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.Comment
+comment :: Typed.TypedTerm Syntax.CommentStyle -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Comment
+comment style text =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Comment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "style"),
+          Core.fieldTerm = (Typed.unTypedTerm style)},
+        Core.Field {
+          Core.fieldName = (Core.Name "text"),
+          Core.fieldTerm = (Typed.unTypedTerm text)}]}))
+
+-- | DSL accessor for the style field of hydra.lisp.syntax.Comment
+commentStyle :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm Syntax.CommentStyle
+commentStyle x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Comment"),
+        Core.projectionFieldName = (Core.Name "style")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the block variant of hydra.lisp.syntax.CommentStyle
+commentStyleBlock :: Typed.TypedTerm Syntax.CommentStyle
+commentStyleBlock =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.CommentStyle"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "block"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the datum variant of hydra.lisp.syntax.CommentStyle
+commentStyleDatum :: Typed.TypedTerm Syntax.CommentStyle
+commentStyleDatum =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.CommentStyle"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "datum"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the line variant of hydra.lisp.syntax.CommentStyle
+commentStyleLine :: Typed.TypedTerm Syntax.CommentStyle
+commentStyleLine =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.CommentStyle"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "line"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL accessor for the text field of hydra.lisp.syntax.Comment
+commentText :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm String
+commentText x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Comment"),
+        Core.projectionFieldName = (Core.Name "text")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the style field of hydra.lisp.syntax.Comment
+commentWithStyle :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm Syntax.CommentStyle -> Typed.TypedTerm Syntax.Comment
+commentWithStyle original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Comment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "style"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "text"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Comment"),
+              Core.projectionFieldName = (Core.Name "text")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the text field of hydra.lisp.syntax.Comment
+commentWithText :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Comment
+commentWithText original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Comment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "style"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Comment"),
+              Core.projectionFieldName = (Core.Name "style")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "text"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.CondClause
+condClause :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CondClause
+condClause condition body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CondClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Typed.unTypedTerm condition)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.CondClause
+condClauseBody :: Typed.TypedTerm Syntax.CondClause -> Typed.TypedTerm Syntax.Expression
+condClauseBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CondClause"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the condition field of hydra.lisp.syntax.CondClause
+condClauseCondition :: Typed.TypedTerm Syntax.CondClause -> Typed.TypedTerm Syntax.Expression
+condClauseCondition x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CondClause"),
+        Core.projectionFieldName = (Core.Name "condition")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.lisp.syntax.CondClause
+condClauseWithBody :: Typed.TypedTerm Syntax.CondClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CondClause
+condClauseWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CondClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CondClause"),
+              Core.projectionFieldName = (Core.Name "condition")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the condition field of hydra.lisp.syntax.CondClause
+condClauseWithCondition :: Typed.TypedTerm Syntax.CondClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CondClause
+condClauseWithCondition original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CondClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CondClause"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.CondExpression
+condExpression :: Typed.TypedTerm [Syntax.CondClause] -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.CondExpression
+condExpression clauses default_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CondExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "clauses"),
+          Core.fieldTerm = (Typed.unTypedTerm clauses)},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))
+
+-- | DSL accessor for the clauses field of hydra.lisp.syntax.CondExpression
+condExpressionClauses :: Typed.TypedTerm Syntax.CondExpression -> Typed.TypedTerm [Syntax.CondClause]
+condExpressionClauses x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CondExpression"),
+        Core.projectionFieldName = (Core.Name "clauses")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the default field of hydra.lisp.syntax.CondExpression
+condExpressionDefault :: Typed.TypedTerm Syntax.CondExpression -> Typed.TypedTerm (Maybe Syntax.Expression)
+condExpressionDefault x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CondExpression"),
+        Core.projectionFieldName = (Core.Name "default")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the clauses field of hydra.lisp.syntax.CondExpression
+condExpressionWithClauses :: Typed.TypedTerm Syntax.CondExpression -> Typed.TypedTerm [Syntax.CondClause] -> Typed.TypedTerm Syntax.CondExpression
+condExpressionWithClauses original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CondExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "clauses"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CondExpression"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the default field of hydra.lisp.syntax.CondExpression
+condExpressionWithDefault :: Typed.TypedTerm Syntax.CondExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.CondExpression
+condExpressionWithDefault original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.CondExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "clauses"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.CondExpression"),
+              Core.projectionFieldName = (Core.Name "clauses")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.ConsExpression
+consExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConsExpression
+consExpression head tail =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConsExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "head"),
+          Core.fieldTerm = (Typed.unTypedTerm head)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tail"),
+          Core.fieldTerm = (Typed.unTypedTerm tail)}]}))
+
+-- | DSL accessor for the head field of hydra.lisp.syntax.ConsExpression
+consExpressionHead :: Typed.TypedTerm Syntax.ConsExpression -> Typed.TypedTerm Syntax.Expression
+consExpressionHead x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConsExpression"),
+        Core.projectionFieldName = (Core.Name "head")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tail field of hydra.lisp.syntax.ConsExpression
+consExpressionTail :: Typed.TypedTerm Syntax.ConsExpression -> Typed.TypedTerm Syntax.Expression
+consExpressionTail x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConsExpression"),
+        Core.projectionFieldName = (Core.Name "tail")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the head field of hydra.lisp.syntax.ConsExpression
+consExpressionWithHead :: Typed.TypedTerm Syntax.ConsExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConsExpression
+consExpressionWithHead original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConsExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "head"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tail"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConsExpression"),
+              Core.projectionFieldName = (Core.Name "tail")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tail field of hydra.lisp.syntax.ConsExpression
+consExpressionWithTail :: Typed.TypedTerm Syntax.ConsExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConsExpression
+consExpressionWithTail original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConsExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "head"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConsExpression"),
+              Core.projectionFieldName = (Core.Name "head")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tail"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.ConstantDefinition
+constantDefinition :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.ConstantDefinition
+constantDefinition name value doc =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm doc)}]}))
+
+-- | DSL accessor for the doc field of hydra.lisp.syntax.ConstantDefinition
+constantDefinitionDoc :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring)
+constantDefinitionDoc x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+        Core.projectionFieldName = (Core.Name "doc")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.ConstantDefinition
+constantDefinitionName :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm Syntax.Symbol
+constantDefinitionName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.ConstantDefinition
+constantDefinitionValue :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm Syntax.Expression
+constantDefinitionValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the doc field of hydra.lisp.syntax.ConstantDefinition
+constantDefinitionWithDoc :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.ConstantDefinition
+constantDefinitionWithDoc original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.ConstantDefinition
+constantDefinitionWithName :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.ConstantDefinition
+constantDefinitionWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.ConstantDefinition
+constantDefinitionWithValue :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConstantDefinition
+constantDefinitionWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstantDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.ConstructorPattern
+constructorPattern :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.ConstructorPattern
+constructorPattern constructor arguments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConstructorPattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constructor"),
+          Core.fieldTerm = (Typed.unTypedTerm constructor)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm arguments)}]}))
+
+-- | DSL accessor for the arguments field of hydra.lisp.syntax.ConstructorPattern
+constructorPatternArguments :: Typed.TypedTerm Syntax.ConstructorPattern -> Typed.TypedTerm [Syntax.Pattern]
+constructorPatternArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstructorPattern"),
+        Core.projectionFieldName = (Core.Name "arguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the constructor field of hydra.lisp.syntax.ConstructorPattern
+constructorPatternConstructor :: Typed.TypedTerm Syntax.ConstructorPattern -> Typed.TypedTerm Syntax.Symbol
+constructorPatternConstructor x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstructorPattern"),
+        Core.projectionFieldName = (Core.Name "constructor")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConstructorPattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constructor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstructorPattern"),
+              Core.projectionFieldName = (Core.Name "constructor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the constructor field of hydra.lisp.syntax.ConstructorPattern
+constructorPatternWithConstructor :: Typed.TypedTerm Syntax.ConstructorPattern -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.ConstructorPattern
+constructorPatternWithConstructor original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ConstructorPattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constructor"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ConstructorPattern"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.DestructuringBinding
+destructuringBinding :: Typed.TypedTerm Syntax.DestructuringPattern -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DestructuringBinding
+destructuringBinding pattern value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.DestructuringBinding"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pattern"),
+          Core.fieldTerm = (Typed.unTypedTerm pattern)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the pattern field of hydra.lisp.syntax.DestructuringBinding
+destructuringBindingPattern :: Typed.TypedTerm Syntax.DestructuringBinding -> Typed.TypedTerm Syntax.DestructuringPattern
+destructuringBindingPattern x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DestructuringBinding"),
+        Core.projectionFieldName = (Core.Name "pattern")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.DestructuringBinding
+destructuringBindingValue :: Typed.TypedTerm Syntax.DestructuringBinding -> Typed.TypedTerm Syntax.Expression
+destructuringBindingValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DestructuringBinding"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the pattern field of hydra.lisp.syntax.DestructuringBinding
+destructuringBindingWithPattern :: Typed.TypedTerm Syntax.DestructuringBinding -> Typed.TypedTerm Syntax.DestructuringPattern -> Typed.TypedTerm Syntax.DestructuringBinding
+destructuringBindingWithPattern original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.DestructuringBinding"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pattern"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DestructuringBinding"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.DestructuringBinding
+destructuringBindingWithValue :: Typed.TypedTerm Syntax.DestructuringBinding -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DestructuringBinding
+destructuringBindingWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.DestructuringBinding"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pattern"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DestructuringBinding"),
+              Core.projectionFieldName = (Core.Name "pattern")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the associative variant of hydra.lisp.syntax.DestructuringPattern
+destructuringPatternAssociative :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.DestructuringPattern
+destructuringPatternAssociative x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.DestructuringPattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "associative"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the rest variant of hydra.lisp.syntax.DestructuringPattern
+destructuringPatternRest :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.DestructuringPattern
+destructuringPatternRest x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.DestructuringPattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "rest"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the sequential variant of hydra.lisp.syntax.DestructuringPattern
+destructuringPatternSequential :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.DestructuringPattern
+destructuringPatternSequential x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.DestructuringPattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "sequential"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the clojure variant of hydra.lisp.syntax.Dialect
+dialectClojure :: Typed.TypedTerm Syntax.Dialect
+dialectClojure =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Dialect"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "clojure"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the commonLisp variant of hydra.lisp.syntax.Dialect
+dialectCommonLisp :: Typed.TypedTerm Syntax.Dialect
+dialectCommonLisp =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Dialect"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "commonLisp"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the emacsLisp variant of hydra.lisp.syntax.Dialect
+dialectEmacsLisp :: Typed.TypedTerm Syntax.Dialect
+dialectEmacsLisp =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Dialect"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "emacsLisp"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the scheme variant of hydra.lisp.syntax.Dialect
+dialectScheme :: Typed.TypedTerm Syntax.Dialect
+dialectScheme =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Dialect"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "scheme"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.lisp.syntax.DoExpression
+doExpression :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.DoExpression
+doExpression expressions =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.DoExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm expressions)}]}))
+
+-- | DSL accessor for the expressions field of hydra.lisp.syntax.DoExpression
+doExpressionExpressions :: Typed.TypedTerm Syntax.DoExpression -> Typed.TypedTerm [Syntax.Expression]
+doExpressionExpressions x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DoExpression"),
+        Core.projectionFieldName = (Core.Name "expressions")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expressions field of hydra.lisp.syntax.DoExpression
+doExpressionWithExpressions :: Typed.TypedTerm Syntax.DoExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.DoExpression
+doExpressionWithExpressions original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.DoExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.lisp.syntax.Docstring wrapper
+docstring :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Docstring
+docstring x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.Docstring"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.lisp.syntax.DottedPair
+dottedPair :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DottedPair
+dottedPair car cdr =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.DottedPair"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "car"),
+          Core.fieldTerm = (Typed.unTypedTerm car)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cdr"),
+          Core.fieldTerm = (Typed.unTypedTerm cdr)}]}))
+
+-- | DSL accessor for the car field of hydra.lisp.syntax.DottedPair
+dottedPairCar :: Typed.TypedTerm Syntax.DottedPair -> Typed.TypedTerm Syntax.Expression
+dottedPairCar x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DottedPair"),
+        Core.projectionFieldName = (Core.Name "car")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cdr field of hydra.lisp.syntax.DottedPair
+dottedPairCdr :: Typed.TypedTerm Syntax.DottedPair -> Typed.TypedTerm Syntax.Expression
+dottedPairCdr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DottedPair"),
+        Core.projectionFieldName = (Core.Name "cdr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.DottedPair"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "car"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cdr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DottedPair"),
+              Core.projectionFieldName = (Core.Name "cdr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the cdr field of hydra.lisp.syntax.DottedPair
+dottedPairWithCdr :: Typed.TypedTerm Syntax.DottedPair -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DottedPair
+dottedPairWithCdr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.DottedPair"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "car"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.DottedPair"),
+              Core.projectionFieldName = (Core.Name "car")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cdr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.ExportDeclaration
+exportDeclaration :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.ExportDeclaration
+exportDeclaration symbols =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ExportDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "symbols"),
+          Core.fieldTerm = (Typed.unTypedTerm symbols)}]}))
+
+-- | DSL accessor for the symbols field of hydra.lisp.syntax.ExportDeclaration
+exportDeclarationSymbols :: Typed.TypedTerm Syntax.ExportDeclaration -> Typed.TypedTerm [Syntax.Symbol]
+exportDeclarationSymbols x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ExportDeclaration"),
+        Core.projectionFieldName = (Core.Name "symbols")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the symbols field of hydra.lisp.syntax.ExportDeclaration
+exportDeclarationWithSymbols :: Typed.TypedTerm Syntax.ExportDeclaration -> Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.ExportDeclaration
+exportDeclarationWithSymbols original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ExportDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "symbols"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the and variant of hydra.lisp.syntax.Expression
+expressionAnd :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.Expression
+expressionAnd x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "and"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the application variant of hydra.lisp.syntax.Expression
+expressionApplication :: Typed.TypedTerm Syntax.Application -> Typed.TypedTerm Syntax.Expression
+expressionApplication x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "application"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the begin variant of hydra.lisp.syntax.Expression
+expressionBegin :: Typed.TypedTerm Syntax.BeginExpression -> Typed.TypedTerm Syntax.Expression
+expressionBegin x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "begin"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the case variant of hydra.lisp.syntax.Expression
+expressionCase :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm Syntax.Expression
+expressionCase x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "case"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the cond variant of hydra.lisp.syntax.Expression
+expressionCond :: Typed.TypedTerm Syntax.CondExpression -> Typed.TypedTerm Syntax.Expression
+expressionCond x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "cond"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the cons variant of hydra.lisp.syntax.Expression
+expressionCons :: Typed.TypedTerm Syntax.ConsExpression -> Typed.TypedTerm Syntax.Expression
+expressionCons x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "cons"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the do variant of hydra.lisp.syntax.Expression
+expressionDo :: Typed.TypedTerm Syntax.DoExpression -> Typed.TypedTerm Syntax.Expression
+expressionDo x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "do"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the dottedPair variant of hydra.lisp.syntax.Expression
+expressionDottedPair :: Typed.TypedTerm Syntax.DottedPair -> Typed.TypedTerm Syntax.Expression
+expressionDottedPair x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "dottedPair"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the fieldAccess variant of hydra.lisp.syntax.Expression
+expressionFieldAccess :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Expression
+expressionFieldAccess x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "fieldAccess"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the if variant of hydra.lisp.syntax.Expression
+expressionIf :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression
+expressionIf x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "if"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the lambda variant of hydra.lisp.syntax.Expression
+expressionLambda :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm Syntax.Expression
+expressionLambda x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lambda"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the let variant of hydra.lisp.syntax.Expression
+expressionLet :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm Syntax.Expression
+expressionLet x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "let"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the list variant of hydra.lisp.syntax.Expression
+expressionList :: Typed.TypedTerm Syntax.ListLiteral -> Typed.TypedTerm Syntax.Expression
+expressionList x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "list"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the literal variant of hydra.lisp.syntax.Expression
+expressionLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Expression
+expressionLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the map variant of hydra.lisp.syntax.Expression
+expressionMap :: Typed.TypedTerm Syntax.MapLiteral -> Typed.TypedTerm Syntax.Expression
+expressionMap x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "map"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the not variant of hydra.lisp.syntax.Expression
+expressionNot :: Typed.TypedTerm Syntax.NotExpression -> Typed.TypedTerm Syntax.Expression
+expressionNot x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "not"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the or variant of hydra.lisp.syntax.Expression
+expressionOr :: Typed.TypedTerm Syntax.OrExpression -> Typed.TypedTerm Syntax.Expression
+expressionOr x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "or"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the quasiquote variant of hydra.lisp.syntax.Expression
+expressionQuasiquote :: Typed.TypedTerm Syntax.QuasiquoteExpression -> Typed.TypedTerm Syntax.Expression
+expressionQuasiquote x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "quasiquote"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the quote variant of hydra.lisp.syntax.Expression
+expressionQuote :: Typed.TypedTerm Syntax.QuoteExpression -> Typed.TypedTerm Syntax.Expression
+expressionQuote x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "quote"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the sExpression variant of hydra.lisp.syntax.Expression
+expressionSExpression :: Typed.TypedTerm Syntax.SExpression -> Typed.TypedTerm Syntax.Expression
+expressionSExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "sExpression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the set variant of hydra.lisp.syntax.Expression
+expressionSet :: Typed.TypedTerm Syntax.SetLiteral -> Typed.TypedTerm Syntax.Expression
+expressionSet x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "set"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the splicingUnquote variant of hydra.lisp.syntax.Expression
+expressionSplicingUnquote :: Typed.TypedTerm Syntax.SplicingUnquoteExpression -> Typed.TypedTerm Syntax.Expression
+expressionSplicingUnquote x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "splicingUnquote"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the typeAnnotation variant of hydra.lisp.syntax.Expression
+expressionTypeAnnotation :: Typed.TypedTerm Syntax.TypeAnnotation -> Typed.TypedTerm Syntax.Expression
+expressionTypeAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typeAnnotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the unquote variant of hydra.lisp.syntax.Expression
+expressionUnquote :: Typed.TypedTerm Syntax.UnquoteExpression -> Typed.TypedTerm Syntax.Expression
+expressionUnquote x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unquote"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variable variant of hydra.lisp.syntax.Expression
+expressionVariable :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.Expression
+expressionVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the vector variant of hydra.lisp.syntax.Expression
+expressionVector :: Typed.TypedTerm Syntax.VectorLiteral -> Typed.TypedTerm Syntax.Expression
+expressionVector x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "vector"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.lisp.syntax.FieldAccess
+fieldAccess :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FieldAccess
+fieldAccess recordType field target =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "recordType"),
+          Core.fieldTerm = (Typed.unTypedTerm recordType)},
+        Core.Field {
+          Core.fieldName = (Core.Name "field"),
+          Core.fieldTerm = (Typed.unTypedTerm field)},
+        Core.Field {
+          Core.fieldName = (Core.Name "target"),
+          Core.fieldTerm = (Typed.unTypedTerm target)}]}))
+
+-- | DSL accessor for the field field of hydra.lisp.syntax.FieldAccess
+fieldAccessField :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Symbol
+fieldAccessField x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+        Core.projectionFieldName = (Core.Name "field")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the recordType field of hydra.lisp.syntax.FieldAccess
+fieldAccessRecordType :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Symbol
+fieldAccessRecordType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+        Core.projectionFieldName = (Core.Name "recordType")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the target field of hydra.lisp.syntax.FieldAccess
+fieldAccessTarget :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Expression
+fieldAccessTarget x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+        Core.projectionFieldName = (Core.Name "target")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the field field of hydra.lisp.syntax.FieldAccess
+fieldAccessWithField :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.FieldAccess
+fieldAccessWithField original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "recordType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+              Core.projectionFieldName = (Core.Name "recordType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "field"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "target"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+              Core.projectionFieldName = (Core.Name "target")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the recordType field of hydra.lisp.syntax.FieldAccess
+fieldAccessWithRecordType :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.FieldAccess
+fieldAccessWithRecordType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "recordType"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "field"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+              Core.projectionFieldName = (Core.Name "field")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "target"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+              Core.projectionFieldName = (Core.Name "target")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the target field of hydra.lisp.syntax.FieldAccess
+fieldAccessWithTarget :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FieldAccess
+fieldAccessWithTarget original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "recordType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+              Core.projectionFieldName = (Core.Name "recordType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "field"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldAccess"),
+              Core.projectionFieldName = (Core.Name "field")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "target"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.FieldDefinition
+fieldDefinition :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.FieldDefinition
+fieldDefinition name defaultValue =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FieldDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Typed.unTypedTerm defaultValue)}]}))
+
+-- | DSL accessor for the defaultValue field of hydra.lisp.syntax.FieldDefinition
+fieldDefinitionDefaultValue :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm (Maybe Syntax.Expression)
+fieldDefinitionDefaultValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldDefinition"),
+        Core.projectionFieldName = (Core.Name "defaultValue")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.FieldDefinition
+fieldDefinitionName :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm Syntax.Symbol
+fieldDefinitionName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldDefinition"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the defaultValue field of hydra.lisp.syntax.FieldDefinition
+fieldDefinitionWithDefaultValue :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.FieldDefinition
+fieldDefinitionWithDefaultValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FieldDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.FieldDefinition
+fieldDefinitionWithName :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.FieldDefinition
+fieldDefinitionWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FieldDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "defaultValue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FieldDefinition"),
+              Core.projectionFieldName = (Core.Name "defaultValue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.FloatLiteral
+floatLiteral :: Typed.TypedTerm Double -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.FloatLiteral
+floatLiteral value precision =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FloatLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)},
+        Core.Field {
+          Core.fieldName = (Core.Name "precision"),
+          Core.fieldTerm = (Typed.unTypedTerm precision)}]}))
+
+-- | DSL accessor for the precision field of hydra.lisp.syntax.FloatLiteral
+floatLiteralPrecision :: Typed.TypedTerm Syntax.FloatLiteral -> Typed.TypedTerm (Maybe String)
+floatLiteralPrecision x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FloatLiteral"),
+        Core.projectionFieldName = (Core.Name "precision")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.FloatLiteral
+floatLiteralValue :: Typed.TypedTerm Syntax.FloatLiteral -> Typed.TypedTerm Double
+floatLiteralValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FloatLiteral"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the precision field of hydra.lisp.syntax.FloatLiteral
+floatLiteralWithPrecision :: Typed.TypedTerm Syntax.FloatLiteral -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.FloatLiteral
+floatLiteralWithPrecision original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FloatLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FloatLiteral"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "precision"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.FloatLiteral
+floatLiteralWithValue :: Typed.TypedTerm Syntax.FloatLiteral -> Typed.TypedTerm Double -> Typed.TypedTerm Syntax.FloatLiteral
+floatLiteralWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FloatLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "precision"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FloatLiteral"),
+              Core.projectionFieldName = (Core.Name "precision")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.FunctionDefinition
+functionDefinition :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm (Maybe Syntax.Symbol) -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm [Syntax.TypeHint] -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.FunctionDefinition
+functionDefinition name params restParam doc typeHints body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm params)},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Typed.unTypedTerm restParam)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm doc)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeHints"),
+          Core.fieldTerm = (Typed.unTypedTerm typeHints)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionBody :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm [Syntax.Expression]
+functionDefinitionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the doc field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionDoc :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring)
+functionDefinitionDoc x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+        Core.projectionFieldName = (Core.Name "doc")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionName :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.Symbol
+functionDefinitionName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the params field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionParams :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm [Syntax.Symbol]
+functionDefinitionParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+        Core.projectionFieldName = (Core.Name "params")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the restParam field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionRestParam :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm (Maybe Syntax.Symbol)
+functionDefinitionRestParam x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+        Core.projectionFieldName = (Core.Name "restParam")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeHints field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionTypeHints :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm [Syntax.TypeHint]
+functionDefinitionTypeHints x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+        Core.projectionFieldName = (Core.Name "typeHints")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionWithBody :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.FunctionDefinition
+functionDefinitionWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeHints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "typeHints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the doc field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionWithDoc :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.FunctionDefinition
+functionDefinitionWithDoc original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeHints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "typeHints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionWithName :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.FunctionDefinition
+functionDefinitionWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeHints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "typeHints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the params field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionWithParams :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.FunctionDefinition
+functionDefinitionWithParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeHints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "typeHints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the restParam field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionWithRestParam :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm (Maybe Syntax.Symbol) -> Typed.TypedTerm Syntax.FunctionDefinition
+functionDefinitionWithRestParam original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeHints"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "typeHints")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeHints field of hydra.lisp.syntax.FunctionDefinition
+functionDefinitionWithTypeHints :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm [Syntax.TypeHint] -> Typed.TypedTerm Syntax.FunctionDefinition
+functionDefinitionWithTypeHints original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeHints"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.FunctionDefinition"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.IfExpression
+ifExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.IfExpression
+ifExpression condition then_ else_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Typed.unTypedTerm condition)},
+        Core.Field {
+          Core.fieldName = (Core.Name "then"),
+          Core.fieldTerm = (Typed.unTypedTerm then_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "else"),
+          Core.fieldTerm = (Typed.unTypedTerm else_)}]}))
+
+-- | DSL accessor for the condition field of hydra.lisp.syntax.IfExpression
+ifExpressionCondition :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression
+ifExpressionCondition x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+        Core.projectionFieldName = (Core.Name "condition")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the else field of hydra.lisp.syntax.IfExpression
+ifExpressionElse :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm (Maybe Syntax.Expression)
+ifExpressionElse x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+        Core.projectionFieldName = (Core.Name "else")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the then field of hydra.lisp.syntax.IfExpression
+ifExpressionThen :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression
+ifExpressionThen x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+        Core.projectionFieldName = (Core.Name "then")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the condition field of hydra.lisp.syntax.IfExpression
+ifExpressionWithCondition :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IfExpression
+ifExpressionWithCondition original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "then"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+              Core.projectionFieldName = (Core.Name "then")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "else"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the else field of hydra.lisp.syntax.IfExpression
+ifExpressionWithElse :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.IfExpression
+ifExpressionWithElse original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+              Core.projectionFieldName = (Core.Name "condition")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "then"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+              Core.projectionFieldName = (Core.Name "then")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "else"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the then field of hydra.lisp.syntax.IfExpression
+ifExpressionWithThen :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IfExpression
+ifExpressionWithThen original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+              Core.projectionFieldName = (Core.Name "condition")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "then"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "else"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IfExpression"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.ImportDeclaration
+importDeclaration :: Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm Syntax.ImportSpec -> Typed.TypedTerm Syntax.ImportDeclaration
+importDeclaration module_ spec =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ImportDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Typed.unTypedTerm module_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "spec"),
+          Core.fieldTerm = (Typed.unTypedTerm spec)}]}))
+
+-- | DSL accessor for the module field of hydra.lisp.syntax.ImportDeclaration
+importDeclarationModule :: Typed.TypedTerm Syntax.ImportDeclaration -> Typed.TypedTerm Syntax.NamespaceName
+importDeclarationModule x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ImportDeclaration"),
+        Core.projectionFieldName = (Core.Name "module")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the spec field of hydra.lisp.syntax.ImportDeclaration
+importDeclarationSpec :: Typed.TypedTerm Syntax.ImportDeclaration -> Typed.TypedTerm Syntax.ImportSpec
+importDeclarationSpec x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ImportDeclaration"),
+        Core.projectionFieldName = (Core.Name "spec")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the module field of hydra.lisp.syntax.ImportDeclaration
+importDeclarationWithModule :: Typed.TypedTerm Syntax.ImportDeclaration -> Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm Syntax.ImportDeclaration
+importDeclarationWithModule original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ImportDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "spec"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ImportDeclaration"),
+              Core.projectionFieldName = (Core.Name "spec")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the spec field of hydra.lisp.syntax.ImportDeclaration
+importDeclarationWithSpec :: Typed.TypedTerm Syntax.ImportDeclaration -> Typed.TypedTerm Syntax.ImportSpec -> Typed.TypedTerm Syntax.ImportDeclaration
+importDeclarationWithSpec original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ImportDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ImportDeclaration"),
+              Core.projectionFieldName = (Core.Name "module")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "spec"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the alias variant of hydra.lisp.syntax.ImportSpec
+importSpecAlias :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.ImportSpec
+importSpecAlias x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.ImportSpec"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "alias"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the all variant of hydra.lisp.syntax.ImportSpec
+importSpecAll :: Typed.TypedTerm Syntax.ImportSpec
+importSpecAll =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.ImportSpec"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "all"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the only variant of hydra.lisp.syntax.ImportSpec
+importSpecOnly :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.ImportSpec
+importSpecOnly x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.ImportSpec"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "only"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the rename variant of hydra.lisp.syntax.ImportSpec
+importSpecRename :: Typed.TypedTerm [[Syntax.Symbol]] -> Typed.TypedTerm Syntax.ImportSpec
+importSpecRename x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.ImportSpec"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "rename"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.lisp.syntax.IntegerLiteral
+integerLiteral :: Typed.TypedTerm Integer -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.IntegerLiteral
+integerLiteral value bigint =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.IntegerLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bigint"),
+          Core.fieldTerm = (Typed.unTypedTerm bigint)}]}))
+
+-- | DSL accessor for the bigint field of hydra.lisp.syntax.IntegerLiteral
+integerLiteralBigint :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Bool
+integerLiteralBigint x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IntegerLiteral"),
+        Core.projectionFieldName = (Core.Name "bigint")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.IntegerLiteral
+integerLiteralValue :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Integer
+integerLiteralValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IntegerLiteral"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the bigint field of hydra.lisp.syntax.IntegerLiteral
+integerLiteralWithBigint :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.IntegerLiteral
+integerLiteralWithBigint original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.IntegerLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IntegerLiteral"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bigint"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.IntegerLiteral
+integerLiteralWithValue :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.IntegerLiteral
+integerLiteralWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.IntegerLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bigint"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.IntegerLiteral"),
+              Core.projectionFieldName = (Core.Name "bigint")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.Keyword
+keyword :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Keyword
+keyword name namespace =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Keyword"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "namespace"),
+          Core.fieldTerm = (Typed.unTypedTerm namespace)}]}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.Keyword
+keywordName :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm String
+keywordName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Keyword"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the namespace field of hydra.lisp.syntax.Keyword
+keywordNamespace :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm (Maybe String)
+keywordNamespace x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Keyword"),
+        Core.projectionFieldName = (Core.Name "namespace")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.Keyword
+keywordWithName :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Keyword
+keywordWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Keyword"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "namespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Keyword"),
+              Core.projectionFieldName = (Core.Name "namespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the namespace field of hydra.lisp.syntax.Keyword
+keywordWithNamespace :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Keyword
+keywordWithNamespace original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Keyword"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Keyword"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "namespace"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.Lambda
+lambda :: Typed.TypedTerm (Maybe Syntax.Symbol) -> Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm (Maybe Syntax.Symbol) -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Lambda
+lambda name params restParam body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm params)},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Typed.unTypedTerm restParam)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.Lambda
+lambdaBody :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm [Syntax.Expression]
+lambdaBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.Lambda
+lambdaName :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm (Maybe Syntax.Symbol)
+lambdaName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the params field of hydra.lisp.syntax.Lambda
+lambdaParams :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm [Syntax.Symbol]
+lambdaParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+        Core.projectionFieldName = (Core.Name "params")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the restParam field of hydra.lisp.syntax.Lambda
+lambdaRestParam :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm (Maybe Syntax.Symbol)
+lambdaRestParam x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+        Core.projectionFieldName = (Core.Name "restParam")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.lisp.syntax.Lambda
+lambdaWithBody :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Lambda
+lambdaWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.Lambda
+lambdaWithName :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm (Maybe Syntax.Symbol) -> Typed.TypedTerm Syntax.Lambda
+lambdaWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the params field of hydra.lisp.syntax.Lambda
+lambdaWithParams :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.Lambda
+lambdaWithParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the restParam field of hydra.lisp.syntax.Lambda
+lambdaWithRestParam :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm (Maybe Syntax.Symbol) -> Typed.TypedTerm Syntax.Lambda
+lambdaWithRestParam original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Lambda"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the destructuring variant of hydra.lisp.syntax.LetBinding
+letBindingDestructuring :: Typed.TypedTerm Syntax.DestructuringBinding -> Typed.TypedTerm Syntax.LetBinding
+letBindingDestructuring x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.LetBinding"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "destructuring"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.lisp.syntax.LetBinding
+letBindingSimple :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.LetBinding
+letBindingSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.LetBinding"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.lisp.syntax.LetExpression
+letExpression :: Typed.TypedTerm Syntax.LetKind -> Typed.TypedTerm [Syntax.LetBinding] -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.LetExpression
+letExpression kind bindings body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "kind"),
+          Core.fieldTerm = (Typed.unTypedTerm kind)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bindings"),
+          Core.fieldTerm = (Typed.unTypedTerm bindings)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the bindings field of hydra.lisp.syntax.LetExpression
+letExpressionBindings :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.LetBinding]
+letExpressionBindings x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+        Core.projectionFieldName = (Core.Name "bindings")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.LetExpression
+letExpressionBody :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.Expression]
+letExpressionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the kind field of hydra.lisp.syntax.LetExpression
+letExpressionKind :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm Syntax.LetKind
+letExpressionKind x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+        Core.projectionFieldName = (Core.Name "kind")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "kind"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+              Core.projectionFieldName = (Core.Name "kind")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bindings"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the body field of hydra.lisp.syntax.LetExpression
+letExpressionWithBody :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.LetExpression
+letExpressionWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "kind"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+              Core.projectionFieldName = (Core.Name "kind")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bindings"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+              Core.projectionFieldName = (Core.Name "bindings")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the kind field of hydra.lisp.syntax.LetExpression
+letExpressionWithKind :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm Syntax.LetKind -> Typed.TypedTerm Syntax.LetExpression
+letExpressionWithKind original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "kind"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bindings"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+              Core.projectionFieldName = (Core.Name "bindings")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LetExpression"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the parallel variant of hydra.lisp.syntax.LetKind
+letKindParallel :: Typed.TypedTerm Syntax.LetKind
+letKindParallel =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.LetKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "parallel"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the recursive variant of hydra.lisp.syntax.LetKind
+letKindRecursive :: Typed.TypedTerm Syntax.LetKind
+letKindRecursive =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.LetKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "recursive"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the sequential variant of hydra.lisp.syntax.LetKind
+letKindSequential :: Typed.TypedTerm Syntax.LetKind
+letKindSequential =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.LetKind"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "sequential"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.lisp.syntax.ListLiteral
+listLiteral :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ListLiteral
+listLiteral elements quoted =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ListLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "elements"),
+          Core.fieldTerm = (Typed.unTypedTerm elements)},
+        Core.Field {
+          Core.fieldName = (Core.Name "quoted"),
+          Core.fieldTerm = (Typed.unTypedTerm quoted)}]}))
+
+-- | DSL accessor for the elements field of hydra.lisp.syntax.ListLiteral
+listLiteralElements :: Typed.TypedTerm Syntax.ListLiteral -> Typed.TypedTerm [Syntax.Expression]
+listLiteralElements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ListLiteral"),
+        Core.projectionFieldName = (Core.Name "elements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the quoted field of hydra.lisp.syntax.ListLiteral
+listLiteralQuoted :: Typed.TypedTerm Syntax.ListLiteral -> Typed.TypedTerm Bool
+listLiteralQuoted x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ListLiteral"),
+        Core.projectionFieldName = (Core.Name "quoted")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the elements field of hydra.lisp.syntax.ListLiteral
+listLiteralWithElements :: Typed.TypedTerm Syntax.ListLiteral -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ListLiteral
+listLiteralWithElements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ListLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "elements"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "quoted"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ListLiteral"),
+              Core.projectionFieldName = (Core.Name "quoted")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the quoted field of hydra.lisp.syntax.ListLiteral
+listLiteralWithQuoted :: Typed.TypedTerm Syntax.ListLiteral -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ListLiteral
+listLiteralWithQuoted original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ListLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "elements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ListLiteral"),
+              Core.projectionFieldName = (Core.Name "elements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "quoted"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the boolean variant of hydra.lisp.syntax.Literal
+literalBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Literal
+literalBoolean x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "boolean"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the character variant of hydra.lisp.syntax.Literal
+literalCharacter :: Typed.TypedTerm Syntax.CharacterLiteral -> Typed.TypedTerm Syntax.Literal
+literalCharacter x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "character"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the float variant of hydra.lisp.syntax.Literal
+literalFloat :: Typed.TypedTerm Syntax.FloatLiteral -> Typed.TypedTerm Syntax.Literal
+literalFloat x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "float"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the integer variant of hydra.lisp.syntax.Literal
+literalInteger :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Syntax.Literal
+literalInteger x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "integer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the keyword variant of hydra.lisp.syntax.Literal
+literalKeyword :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm Syntax.Literal
+literalKeyword x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "keyword"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the nil variant of hydra.lisp.syntax.Literal
+literalNil :: Typed.TypedTerm Syntax.Literal
+literalNil =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "nil"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.lisp.syntax.LiteralPattern
+literalPattern :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.LiteralPattern
+literalPattern value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.LiteralPattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.LiteralPattern
+literalPatternValue :: Typed.TypedTerm Syntax.LiteralPattern -> Typed.TypedTerm Syntax.Literal
+literalPatternValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.LiteralPattern"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.LiteralPattern
+literalPatternWithValue :: Typed.TypedTerm Syntax.LiteralPattern -> Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.LiteralPattern
+literalPatternWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.LiteralPattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the string variant of hydra.lisp.syntax.Literal
+literalString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal
+literalString x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "string"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the symbol variant of hydra.lisp.syntax.Literal
+literalSymbol :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Literal
+literalSymbol x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "symbol"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.lisp.syntax.MacroDefinition
+macroDefinition :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm (Maybe Syntax.Symbol) -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.MacroDefinition
+macroDefinition name params restParam body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm params)},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Typed.unTypedTerm restParam)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.MacroDefinition
+macroDefinitionBody :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm [Syntax.Expression]
+macroDefinitionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.MacroDefinition
+macroDefinitionName :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm Syntax.Symbol
+macroDefinitionName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the params field of hydra.lisp.syntax.MacroDefinition
+macroDefinitionParams :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm [Syntax.Symbol]
+macroDefinitionParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+        Core.projectionFieldName = (Core.Name "params")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the restParam field of hydra.lisp.syntax.MacroDefinition
+macroDefinitionRestParam :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm (Maybe Syntax.Symbol)
+macroDefinitionRestParam x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+        Core.projectionFieldName = (Core.Name "restParam")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.lisp.syntax.MacroDefinition
+macroDefinitionWithBody :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.MacroDefinition
+macroDefinitionWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.MacroDefinition
+macroDefinitionWithName :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.MacroDefinition
+macroDefinitionWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the params field of hydra.lisp.syntax.MacroDefinition
+macroDefinitionWithParams :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.MacroDefinition
+macroDefinitionWithParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "restParam")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the restParam field of hydra.lisp.syntax.MacroDefinition
+macroDefinitionWithRestParam :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm (Maybe Syntax.Symbol) -> Typed.TypedTerm Syntax.MacroDefinition
+macroDefinitionWithRestParam original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "restParam"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MacroDefinition"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.MapEntry
+mapEntry :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MapEntry
+mapEntry key value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MapEntry"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "key"),
+          Core.fieldTerm = (Typed.unTypedTerm key)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the key field of hydra.lisp.syntax.MapEntry
+mapEntryKey :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression
+mapEntryKey x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MapEntry"),
+        Core.projectionFieldName = (Core.Name "key")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.MapEntry
+mapEntryValue :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression
+mapEntryValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MapEntry"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the key field of hydra.lisp.syntax.MapEntry
+mapEntryWithKey :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MapEntry
+mapEntryWithKey original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MapEntry"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "key"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MapEntry"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.MapEntry
+mapEntryWithValue :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MapEntry
+mapEntryWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MapEntry"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "key"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MapEntry"),
+              Core.projectionFieldName = (Core.Name "key")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.MapLiteral
+mapLiteral :: Typed.TypedTerm [Syntax.MapEntry] -> Typed.TypedTerm Syntax.MapLiteral
+mapLiteral entries =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MapLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "entries"),
+          Core.fieldTerm = (Typed.unTypedTerm entries)}]}))
+
+-- | DSL accessor for the entries field of hydra.lisp.syntax.MapLiteral
+mapLiteralEntries :: Typed.TypedTerm Syntax.MapLiteral -> Typed.TypedTerm [Syntax.MapEntry]
+mapLiteralEntries x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.MapLiteral"),
+        Core.projectionFieldName = (Core.Name "entries")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.MapLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "entries"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.ModuleDeclaration
+moduleDeclaration :: Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.ModuleDeclaration
+moduleDeclaration name doc =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ModuleDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm doc)}]}))
+
+-- | DSL accessor for the doc field of hydra.lisp.syntax.ModuleDeclaration
+moduleDeclarationDoc :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm (Maybe Syntax.Docstring)
+moduleDeclarationDoc x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ModuleDeclaration"),
+        Core.projectionFieldName = (Core.Name "doc")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.ModuleDeclaration
+moduleDeclarationName :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm Syntax.NamespaceName
+moduleDeclarationName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ModuleDeclaration"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the doc field of hydra.lisp.syntax.ModuleDeclaration
+moduleDeclarationWithDoc :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.ModuleDeclaration
+moduleDeclarationWithDoc original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ModuleDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.ModuleDeclaration
+moduleDeclarationWithName :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm Syntax.ModuleDeclaration
+moduleDeclarationWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.ModuleDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.lisp.syntax.NamespaceName wrapper
+namespaceName :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.NamespaceName
+namespaceName x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.NamespaceName"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the emptyList variant of hydra.lisp.syntax.NilStyle
+nilStyleEmptyList :: Typed.TypedTerm Syntax.NilStyle
+nilStyleEmptyList =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.NilStyle"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "emptyList"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the nil variant of hydra.lisp.syntax.NilStyle
+nilStyleNil :: Typed.TypedTerm Syntax.NilStyle
+nilStyleNil =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.NilStyle"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "nil"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.lisp.syntax.NotExpression
+notExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.NotExpression
+notExpression expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.NotExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.lisp.syntax.NotExpression
+notExpressionExpression :: Typed.TypedTerm Syntax.NotExpression -> Typed.TypedTerm Syntax.Expression
+notExpressionExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.NotExpression"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.NotExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.OrExpression
+orExpression :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.OrExpression
+orExpression expressions =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.OrExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm expressions)}]}))
+
+-- | DSL accessor for the expressions field of hydra.lisp.syntax.OrExpression
+orExpressionExpressions :: Typed.TypedTerm Syntax.OrExpression -> Typed.TypedTerm [Syntax.Expression]
+orExpressionExpressions x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.OrExpression"),
+        Core.projectionFieldName = (Core.Name "expressions")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.OrExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the constructor variant of hydra.lisp.syntax.Pattern
+patternConstructor :: Typed.TypedTerm Syntax.ConstructorPattern -> Typed.TypedTerm Syntax.Pattern
+patternConstructor x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Pattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "constructor"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the literal variant of hydra.lisp.syntax.Pattern
+patternLiteral :: Typed.TypedTerm Syntax.LiteralPattern -> Typed.TypedTerm Syntax.Pattern
+patternLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Pattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variable variant of hydra.lisp.syntax.Pattern
+patternVariable :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Pattern
+patternVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Pattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the wildcard variant of hydra.lisp.syntax.Pattern
+patternWildcard :: Typed.TypedTerm Syntax.WildcardPattern -> Typed.TypedTerm Syntax.Pattern
+patternWildcard x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.Pattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "wildcard"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.lisp.syntax.Program
+program :: Typed.TypedTerm Syntax.Dialect -> Typed.TypedTerm (Maybe Syntax.ModuleDeclaration) -> Typed.TypedTerm [Syntax.ImportDeclaration] -> Typed.TypedTerm [Syntax.ExportDeclaration] -> Typed.TypedTerm [Syntax.TopLevelFormWithComments] -> Typed.TypedTerm Syntax.Program
+program dialect module_ imports exports forms =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dialect"),
+          Core.fieldTerm = (Typed.unTypedTerm dialect)},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Typed.unTypedTerm module_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Typed.unTypedTerm imports)},
+        Core.Field {
+          Core.fieldName = (Core.Name "exports"),
+          Core.fieldTerm = (Typed.unTypedTerm exports)},
+        Core.Field {
+          Core.fieldName = (Core.Name "forms"),
+          Core.fieldTerm = (Typed.unTypedTerm forms)}]}))
+
+-- | DSL accessor for the dialect field of hydra.lisp.syntax.Program
+programDialect :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm Syntax.Dialect
+programDialect x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+        Core.projectionFieldName = (Core.Name "dialect")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the exports field of hydra.lisp.syntax.Program
+programExports :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.ExportDeclaration]
+programExports x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+        Core.projectionFieldName = (Core.Name "exports")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the forms field of hydra.lisp.syntax.Program
+programForms :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.TopLevelFormWithComments]
+programForms x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+        Core.projectionFieldName = (Core.Name "forms")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the imports field of hydra.lisp.syntax.Program
+programImports :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.ImportDeclaration]
+programImports x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+        Core.projectionFieldName = (Core.Name "imports")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the module field of hydra.lisp.syntax.Program
+programModule :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm (Maybe Syntax.ModuleDeclaration)
+programModule x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+        Core.projectionFieldName = (Core.Name "module")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dialect"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "module")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "exports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "exports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "forms"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "forms")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the exports field of hydra.lisp.syntax.Program
+programWithExports :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.ExportDeclaration] -> Typed.TypedTerm Syntax.Program
+programWithExports original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dialect"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "dialect")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "module")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "exports"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "forms"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "forms")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the forms field of hydra.lisp.syntax.Program
+programWithForms :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.TopLevelFormWithComments] -> Typed.TypedTerm Syntax.Program
+programWithForms original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dialect"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "dialect")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "module")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "exports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "exports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "forms"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the imports field of hydra.lisp.syntax.Program
+programWithImports :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm [Syntax.ImportDeclaration] -> Typed.TypedTerm Syntax.Program
+programWithImports original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dialect"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "dialect")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "module")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "exports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "exports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "forms"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "forms")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the module field of hydra.lisp.syntax.Program
+programWithModule :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm (Maybe Syntax.ModuleDeclaration) -> Typed.TypedTerm Syntax.Program
+programWithModule original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dialect"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "dialect")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "exports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "exports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "forms"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.Program"),
+              Core.projectionFieldName = (Core.Name "forms")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.QualifiedSymbol
+qualifiedSymbol :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.QualifiedSymbol
+qualifiedSymbol namespace name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.QualifiedSymbol"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "namespace"),
+          Core.fieldTerm = (Typed.unTypedTerm namespace)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.QualifiedSymbol
+qualifiedSymbolName :: Typed.TypedTerm Syntax.QualifiedSymbol -> Typed.TypedTerm String
+qualifiedSymbolName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.QualifiedSymbol"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the namespace field of hydra.lisp.syntax.QualifiedSymbol
+qualifiedSymbolNamespace :: Typed.TypedTerm Syntax.QualifiedSymbol -> Typed.TypedTerm String
+qualifiedSymbolNamespace x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.QualifiedSymbol"),
+        Core.projectionFieldName = (Core.Name "namespace")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.QualifiedSymbol"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "namespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.QualifiedSymbol"),
+              Core.projectionFieldName = (Core.Name "namespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the namespace field of hydra.lisp.syntax.QualifiedSymbol
+qualifiedSymbolWithNamespace :: Typed.TypedTerm Syntax.QualifiedSymbol -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.QualifiedSymbol
+qualifiedSymbolWithNamespace original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.QualifiedSymbol"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "namespace"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.QualifiedSymbol"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.QuasiquoteExpression
+quasiquoteExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.QuasiquoteExpression
+quasiquoteExpression body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.QuasiquoteExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.QuasiquoteExpression
+quasiquoteExpressionBody :: Typed.TypedTerm Syntax.QuasiquoteExpression -> Typed.TypedTerm Syntax.Expression
+quasiquoteExpressionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.QuasiquoteExpression"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.QuasiquoteExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.QuoteExpression
+quoteExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.QuoteExpression
+quoteExpression body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.QuoteExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.QuoteExpression
+quoteExpressionBody :: Typed.TypedTerm Syntax.QuoteExpression -> Typed.TypedTerm Syntax.Expression
+quoteExpressionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.QuoteExpression"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.QuoteExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.RecordTypeDefinition
+recordTypeDefinition :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm [Syntax.FieldDefinition] -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.RecordTypeDefinition
+recordTypeDefinition name fields doc =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "fields"),
+          Core.fieldTerm = (Typed.unTypedTerm fields)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm doc)}]}))
+
+-- | DSL accessor for the doc field of hydra.lisp.syntax.RecordTypeDefinition
+recordTypeDefinitionDoc :: Typed.TypedTerm Syntax.RecordTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring)
+recordTypeDefinitionDoc x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+        Core.projectionFieldName = (Core.Name "doc")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the fields field of hydra.lisp.syntax.RecordTypeDefinition
+recordTypeDefinitionFields :: Typed.TypedTerm Syntax.RecordTypeDefinition -> Typed.TypedTerm [Syntax.FieldDefinition]
+recordTypeDefinitionFields x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+        Core.projectionFieldName = (Core.Name "fields")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.RecordTypeDefinition
+recordTypeDefinitionName :: Typed.TypedTerm Syntax.RecordTypeDefinition -> Typed.TypedTerm Syntax.Symbol
+recordTypeDefinitionName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "fields"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+              Core.projectionFieldName = (Core.Name "fields")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the fields field of hydra.lisp.syntax.RecordTypeDefinition
+recordTypeDefinitionWithFields :: Typed.TypedTerm Syntax.RecordTypeDefinition -> Typed.TypedTerm [Syntax.FieldDefinition] -> Typed.TypedTerm Syntax.RecordTypeDefinition
+recordTypeDefinitionWithFields original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "fields"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.RecordTypeDefinition
+recordTypeDefinitionWithName :: Typed.TypedTerm Syntax.RecordTypeDefinition -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.RecordTypeDefinition
+recordTypeDefinitionWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "fields"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+              Core.projectionFieldName = (Core.Name "fields")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.RecordTypeDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the atom variant of hydra.lisp.syntax.SExpression
+sExpressionAtom :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.SExpression
+sExpressionAtom x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.SExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "atom"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the list variant of hydra.lisp.syntax.SExpression
+sExpressionList :: Typed.TypedTerm [Syntax.SExpression] -> Typed.TypedTerm Syntax.SExpression
+sExpressionList x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.SExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "list"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.lisp.syntax.SetLiteral
+setLiteral :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.SetLiteral
+setLiteral elements =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.SetLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "elements"),
+          Core.fieldTerm = (Typed.unTypedTerm elements)}]}))
+
+-- | DSL accessor for the elements field of hydra.lisp.syntax.SetLiteral
+setLiteralElements :: Typed.TypedTerm Syntax.SetLiteral -> Typed.TypedTerm [Syntax.Expression]
+setLiteralElements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.SetLiteral"),
+        Core.projectionFieldName = (Core.Name "elements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.SetLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "elements"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.SimpleBinding
+simpleBinding :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleBinding
+simpleBinding name value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.SimpleBinding"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.SimpleBinding
+simpleBindingName :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.Symbol
+simpleBindingName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.SimpleBinding"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.SimpleBinding
+simpleBindingValue :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.Expression
+simpleBindingValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.SimpleBinding"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.SimpleBinding
+simpleBindingWithName :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.SimpleBinding
+simpleBindingWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.SimpleBinding"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.SimpleBinding"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.SimpleBinding
+simpleBindingWithValue :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleBinding
+simpleBindingWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.SimpleBinding"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.SimpleBinding"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.SplicingUnquoteExpression
+splicingUnquoteExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SplicingUnquoteExpression
+splicingUnquoteExpression body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.SplicingUnquoteExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.SplicingUnquoteExpression
+splicingUnquoteExpressionBody :: Typed.TypedTerm Syntax.SplicingUnquoteExpression -> Typed.TypedTerm Syntax.Expression
+splicingUnquoteExpressionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.SplicingUnquoteExpression"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.SplicingUnquoteExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.lisp.syntax.Symbol wrapper
+symbol :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Symbol
+symbol x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.Symbol"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the constant variant of hydra.lisp.syntax.TopLevelForm
+topLevelFormConstant :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm Syntax.TopLevelForm
+topLevelFormConstant x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelForm"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "constant"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the expression variant of hydra.lisp.syntax.TopLevelForm
+topLevelFormExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TopLevelForm
+topLevelFormExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelForm"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the function variant of hydra.lisp.syntax.TopLevelForm
+topLevelFormFunction :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.TopLevelForm
+topLevelFormFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelForm"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "function"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the macro variant of hydra.lisp.syntax.TopLevelForm
+topLevelFormMacro :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm Syntax.TopLevelForm
+topLevelFormMacro x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelForm"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "macro"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the recordType variant of hydra.lisp.syntax.TopLevelForm
+topLevelFormRecordType :: Typed.TypedTerm Syntax.RecordTypeDefinition -> Typed.TypedTerm Syntax.TopLevelForm
+topLevelFormRecordType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelForm"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "recordType"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variable variant of hydra.lisp.syntax.TopLevelForm
+topLevelFormVariable :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm Syntax.TopLevelForm
+topLevelFormVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelForm"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.lisp.syntax.TopLevelFormWithComments
+topLevelFormWithComments :: Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm (Maybe Syntax.Comment) -> Typed.TypedTerm Syntax.TopLevelForm -> Typed.TypedTerm Syntax.TopLevelFormWithComments
+topLevelFormWithComments doc comment form =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm doc)},
+        Core.Field {
+          Core.fieldName = (Core.Name "comment"),
+          Core.fieldTerm = (Typed.unTypedTerm comment)},
+        Core.Field {
+          Core.fieldName = (Core.Name "form"),
+          Core.fieldTerm = (Typed.unTypedTerm form)}]}))
+
+-- | DSL accessor for the comment field of hydra.lisp.syntax.TopLevelFormWithComments
+topLevelFormWithCommentsComment :: Typed.TypedTerm Syntax.TopLevelFormWithComments -> Typed.TypedTerm (Maybe Syntax.Comment)
+topLevelFormWithCommentsComment x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+        Core.projectionFieldName = (Core.Name "comment")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the doc field of hydra.lisp.syntax.TopLevelFormWithComments
+topLevelFormWithCommentsDoc :: Typed.TypedTerm Syntax.TopLevelFormWithComments -> Typed.TypedTerm (Maybe Syntax.Docstring)
+topLevelFormWithCommentsDoc x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+        Core.projectionFieldName = (Core.Name "doc")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the form field of hydra.lisp.syntax.TopLevelFormWithComments
+topLevelFormWithCommentsForm :: Typed.TypedTerm Syntax.TopLevelFormWithComments -> Typed.TypedTerm Syntax.TopLevelForm
+topLevelFormWithCommentsForm x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+        Core.projectionFieldName = (Core.Name "form")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "comment"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "form"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+              Core.projectionFieldName = (Core.Name "form")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the doc field of hydra.lisp.syntax.TopLevelFormWithComments
+topLevelFormWithCommentsWithDoc :: Typed.TypedTerm Syntax.TopLevelFormWithComments -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.TopLevelFormWithComments
+topLevelFormWithCommentsWithDoc original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "comment"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+              Core.projectionFieldName = (Core.Name "comment")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "form"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+              Core.projectionFieldName = (Core.Name "form")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the form field of hydra.lisp.syntax.TopLevelFormWithComments
+topLevelFormWithCommentsWithForm :: Typed.TypedTerm Syntax.TopLevelFormWithComments -> Typed.TypedTerm Syntax.TopLevelForm -> Typed.TypedTerm Syntax.TopLevelFormWithComments
+topLevelFormWithCommentsWithForm original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "comment"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"),
+              Core.projectionFieldName = (Core.Name "comment")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "form"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.TypeAnnotation
+typeAnnotation :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeSpecifier -> Typed.TypedTerm Syntax.TypeAnnotation
+typeAnnotation expression type_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TypeAnnotation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))
+
+-- | DSL accessor for the expression field of hydra.lisp.syntax.TypeAnnotation
+typeAnnotationExpression :: Typed.TypedTerm Syntax.TypeAnnotation -> Typed.TypedTerm Syntax.Expression
+typeAnnotationExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TypeAnnotation"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.lisp.syntax.TypeAnnotation
+typeAnnotationType :: Typed.TypedTerm Syntax.TypeAnnotation -> Typed.TypedTerm Syntax.TypeSpecifier
+typeAnnotationType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TypeAnnotation"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TypeAnnotation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TypeAnnotation"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.lisp.syntax.TypeAnnotation
+typeAnnotationWithType :: Typed.TypedTerm Syntax.TypeAnnotation -> Typed.TypedTerm Syntax.TypeSpecifier -> Typed.TypedTerm Syntax.TypeAnnotation
+typeAnnotationWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TypeAnnotation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TypeAnnotation"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.TypeHint
+typeHint :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.TypeSpecifier -> Typed.TypedTerm Syntax.TypeHint
+typeHint name type_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TypeHint"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.TypeHint
+typeHintName :: Typed.TypedTerm Syntax.TypeHint -> Typed.TypedTerm Syntax.Symbol
+typeHintName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TypeHint"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.lisp.syntax.TypeHint
+typeHintType :: Typed.TypedTerm Syntax.TypeHint -> Typed.TypedTerm Syntax.TypeSpecifier
+typeHintType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TypeHint"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TypeHint"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TypeHint"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.lisp.syntax.TypeHint
+typeHintWithType :: Typed.TypedTerm Syntax.TypeHint -> Typed.TypedTerm Syntax.TypeSpecifier -> Typed.TypedTerm Syntax.TypeHint
+typeHintWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.TypeHint"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.TypeHint"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the either variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierEither :: Typed.TypedTerm [Syntax.TypeSpecifier] -> Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierEither x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "either"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the function variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierFunction :: Typed.TypedTerm [Syntax.TypeSpecifier] -> Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "function"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the list variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierList :: Typed.TypedTerm Syntax.TypeSpecifier -> Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierList x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "list"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the map variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierMap :: Typed.TypedTerm [Syntax.TypeSpecifier] -> Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierMap x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "map"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the maybe variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierMaybe :: Typed.TypedTerm Syntax.TypeSpecifier -> Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierMaybe x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "maybe"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the named variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierNamed :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierNamed x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "named"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the pair variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierPair :: Typed.TypedTerm [Syntax.TypeSpecifier] -> Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierPair x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "pair"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the set variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierSet :: Typed.TypedTerm Syntax.TypeSpecifier -> Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierSet x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "set"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the unit variant of hydra.lisp.syntax.TypeSpecifier
+typeSpecifierUnit :: Typed.TypedTerm Syntax.TypeSpecifier
+typeSpecifierUnit =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.lisp.syntax.TypeSpecifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unit"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL accessor for the body of hydra.lisp.syntax.Docstring
+unDocstring :: Typed.TypedTerm Syntax.Docstring -> Typed.TypedTerm String
+unDocstring x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.lisp.syntax.Docstring")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.lisp.syntax.NamespaceName
+unNamespaceName :: Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm String
+unNamespaceName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.lisp.syntax.NamespaceName")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.lisp.syntax.Symbol
+unSymbol :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm String
+unSymbol x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.lisp.syntax.Symbol")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.lisp.syntax.UnquoteExpression
+unquoteExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.UnquoteExpression
+unquoteExpression body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.UnquoteExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.lisp.syntax.UnquoteExpression
+unquoteExpressionBody :: Typed.TypedTerm Syntax.UnquoteExpression -> Typed.TypedTerm Syntax.Expression
+unquoteExpressionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.UnquoteExpression"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.UnquoteExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.VariableDefinition
+variableDefinition :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.VariableDefinition
+variableDefinition name value doc =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm doc)}]}))
+
+-- | DSL accessor for the doc field of hydra.lisp.syntax.VariableDefinition
+variableDefinitionDoc :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring)
+variableDefinitionDoc x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+        Core.projectionFieldName = (Core.Name "doc")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.VariableDefinition
+variableDefinitionName :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm Syntax.Symbol
+variableDefinitionName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.lisp.syntax.VariableDefinition
+variableDefinitionValue :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm Syntax.Expression
+variableDefinitionValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.VariableDefinition
+variableDefinitionWithName :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.VariableDefinition
+variableDefinitionWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.lisp.syntax.VariableDefinition
+variableDefinitionWithValue :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.VariableDefinition
+variableDefinitionWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "doc"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableDefinition"),
+              Core.projectionFieldName = (Core.Name "doc")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.VariableReference
+variableReference :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.VariableReference
+variableReference name functionNamespace =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VariableReference"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "functionNamespace"),
+          Core.fieldTerm = (Typed.unTypedTerm functionNamespace)}]}))
+
+-- | DSL accessor for the functionNamespace field of hydra.lisp.syntax.VariableReference
+variableReferenceFunctionNamespace :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Bool
+variableReferenceFunctionNamespace x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableReference"),
+        Core.projectionFieldName = (Core.Name "functionNamespace")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.lisp.syntax.VariableReference
+variableReferenceName :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.Symbol
+variableReferenceName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableReference"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VariableReference"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableReference"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "functionNamespace"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.lisp.syntax.VariableReference
+variableReferenceWithName :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.VariableReference
+variableReferenceWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VariableReference"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "functionNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VariableReference"),
+              Core.projectionFieldName = (Core.Name "functionNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.lisp.syntax.VectorLiteral
+vectorLiteral :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.VectorLiteral
+vectorLiteral elements =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VectorLiteral"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "elements"),
+          Core.fieldTerm = (Typed.unTypedTerm elements)}]}))
+
+-- | DSL accessor for the elements field of hydra.lisp.syntax.VectorLiteral
+vectorLiteralElements :: Typed.TypedTerm Syntax.VectorLiteral -> Typed.TypedTerm [Syntax.Expression]
+vectorLiteralElements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.lisp.syntax.VectorLiteral"),
+        Core.projectionFieldName = (Core.Name "elements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | 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 =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.VectorLiteral"),
+      Core.recordFields = [
+        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 = []}))
diff --git a/src/main/haskell/Hydra/Lisp/Coder.hs b/src/main/haskell/Hydra/Lisp/Coder.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Lisp/Coder.hs
@@ -0,0 +1,625 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Lisp code generator: converts Hydra type and term modules to Lisp AST
+
+module Hydra.Lisp.Coder where
+
+import qualified Hydra.Analysis as Analysis
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Docs as Docs
+import qualified Hydra.Environment as Environment
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.File as ErrorFile
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Error.System as ErrorSystem
+import qualified Hydra.Errors as Errors
+import qualified Hydra.File as File
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Lexical as Lexical
+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers
+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Lisp.Language as Language
+import qualified Hydra.Lisp.Syntax as Syntax
+import qualified Hydra.Names as Names
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Predicates as Predicates
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Show.Core as ShowCore
+import qualified Hydra.Sorting as Sorting
+import qualified Hydra.Strip as Strip
+import qualified Hydra.System as System
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Time as Time
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variables as Variables
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+dialectCadr :: Syntax.Dialect -> String
+dialectCadr d =
+    case d of
+      Syntax.DialectClojure -> "second"
+      _ -> "cadr"
+
+dialectCar :: Syntax.Dialect -> String
+dialectCar d =
+    case d of
+      Syntax.DialectClojure -> "first"
+      _ -> "car"
+
+dialectConstructorPrefix :: Syntax.Dialect -> String
+dialectConstructorPrefix d =
+    case d of
+      Syntax.DialectClojure -> "->"
+      _ -> "make-"
+
+dialectEqual :: Syntax.Dialect -> String
+dialectEqual d =
+    case d of
+      Syntax.DialectClojure -> "="
+      Syntax.DialectCommonLisp -> "equal"
+      Syntax.DialectEmacsLisp -> "equal"
+      _ -> "equal?"
+
+dialectSupportsLetrec :: Syntax.Dialect -> Bool
+dialectSupportsLetrec d =
+    case d of
+      Syntax.DialectClojure -> False
+      _ -> True
+
+encodeApplication :: Syntax.Dialect -> t0 -> Graph.Graph -> Core.Term -> Core.Term -> Either t1 Syntax.Expression
+encodeApplication dialect cx g rawFun rawArg =
+
+      let dFun = Strip.deannotateTerm rawFun
+          normal =
+                  \_ -> Eithers.bind (encodeTerm dialect cx g rawFun) (\fun -> Eithers.bind (encodeTerm dialect cx g rawArg) (\arg -> Right (lispApp fun [
+                    arg])))
+          enc = \t -> encodeTerm dialect cx g t
+      in case dFun of
+        Core.TermApplication v0 ->
+          let midFun = Core.applicationFunction v0
+              midArg = Core.applicationArgument v0
+              dMidFun = Strip.deannotateTerm midFun
+              isLazy2 = primIsLazyAt g dMidFun 0
+          in (Logic.ifElse isLazy2 (Eithers.bind (enc midFun) (\ePrim -> Eithers.bind (enc midArg) (\eDef -> Eithers.bind (enc rawArg) (\eArg -> Right (lispApp (lispApp ePrim [
+            wrapInThunk eDef]) [
+            eArg]))))) (case dMidFun of
+            Core.TermApplication v1 ->
+              let innerFun = Core.applicationFunction v1
+                  innerArg = Core.applicationArgument v1
+                  dInnerFun = Strip.deannotateTerm innerFun
+              in (Logic.ifElse (isPrimitiveRef "hydra.lib.logic.ifElse" dInnerFun) (Eithers.bind (enc innerArg) (\eC -> Eithers.bind (enc midArg) (\eT -> Eithers.bind (enc rawArg) (\eE -> Right (Syntax.ExpressionIf (Syntax.IfExpression {
+                Syntax.ifExpressionCondition = eC,
+                Syntax.ifExpressionThen = eT,
+                Syntax.ifExpressionElse = (Just eE)})))))) (Logic.ifElse (primIsLazyAt g dInnerFun 0) (Eithers.bind (enc innerFun) (\eP -> Eithers.bind (enc innerArg) (\eDef -> Eithers.bind (enc midArg) (\eF -> Eithers.bind (enc rawArg) (\eM -> Right (lispApp (lispApp (lispApp eP [
+                wrapInThunk eDef]) [
+                eF]) [
+                eM])))))) (Logic.ifElse (primIsLazyAt g dInnerFun 1) (Eithers.bind (enc innerFun) (\eP -> Eithers.bind (enc innerArg) (\eM -> Eithers.bind (enc midArg) (\eN -> Eithers.bind (enc rawArg) (\eJ -> Right (lispApp (lispApp (lispApp eP [
+                eM]) [
+                wrapInThunk eN]) [
+                eJ])))))) (normal ()))))
+            _ -> normal ()))
+        _ -> normal ()
+
+encodeFieldDef :: Core.FieldType -> Syntax.FieldDefinition
+encodeFieldDef ft =
+
+      let fname = Core.unName (Core.fieldTypeName ft)
+      in Syntax.FieldDefinition {
+        Syntax.fieldDefinitionName = (Syntax.Symbol (Formatting.convertCaseCamelToLowerSnake fname)),
+        Syntax.fieldDefinitionDefaultValue = Nothing}
+
+encodeLambdaTerm :: Syntax.Dialect -> t0 -> Graph.Graph -> Core.Lambda -> Either t1 Syntax.Expression
+encodeLambdaTerm dialect cx g lam =
+
+      let param =
+              Formatting.convertCaseCamelOrUnderscoreToLowerSnake (Formatting.sanitizeWithUnderscores Language.lispReservedWords (Core.unName (Core.lambdaParameter lam)))
+      in (Eithers.bind (encodeTerm dialect cx g (Core.lambdaBody lam)) (\body -> Right (lispLambdaExpr [
+        param] body)))
+
+encodeLetAsLambdaApp :: Syntax.Dialect -> t0 -> Graph.Graph -> [Core.Binding] -> Core.Term -> Either t1 Syntax.Expression
+encodeLetAsLambdaApp dialect cx g bindings body =
+    Eithers.bind (encodeTerm dialect cx g body) (\bodyExpr -> Eithers.foldl (\acc -> \b ->
+      let bname =
+              Formatting.convertCaseCamelOrUnderscoreToLowerSnake (Formatting.sanitizeWithUnderscores Language.lispReservedWords (Core.unName (Core.bindingName b)))
+      in (Eithers.bind (encodeTerm dialect cx g (Core.bindingTerm b)) (\bval -> Right (lispApp (lispLambdaExpr [
+        bname] acc) [
+        bval])))) bodyExpr (Lists.reverse bindings))
+
+encodeLetAsNative :: Syntax.Dialect -> t0 -> Graph.Graph -> [Core.Binding] -> Core.Term -> Either t1 Syntax.Expression
+encodeLetAsNative dialect cx g bindings body =
+    Eithers.bind (encodeTerm dialect cx g body) (\bodyExpr ->
+      let supportsLetrec = dialectSupportsLetrec dialect
+          allNames = Sets.fromList (Lists.map (\b -> Core.bindingName b) bindings)
+          adjList =
+                  Lists.map (\b -> (Core.bindingName b, (Sets.toList (Sets.intersection allNames (Variables.freeVariablesInTerm (Core.bindingTerm b)))))) bindings
+          sccs = Sorting.topologicalSortComponents adjList
+          nameToBinding = Maps.fromList (Lists.map (\b -> (Core.bindingName b, b)) bindings)
+          sortedBindings = Optionals.cat (Lists.map (\name -> Maps.lookup name nameToBinding) (Lists.concat sccs))
+          hasCycle = Lists.foldl (\acc -> \scc -> Logic.or acc (Equality.gt (Lists.length scc) 1)) False sccs
+      in (Eithers.bind (Eithers.mapList (\b ->
+        let bname =
+                Formatting.convertCaseCamelOrUnderscoreToLowerSnake (Formatting.sanitizeWithUnderscores Language.lispReservedWords (Core.unName (Core.bindingName b)))
+            isSelfRef = Sets.member (Core.bindingName b) (Variables.freeVariablesInTerm (Core.bindingTerm b))
+            isLambda =
+                    case (Strip.deannotateTerm (Core.bindingTerm b)) of
+                      Core.TermLambda _ -> True
+                      _ -> False
+        in (Eithers.bind (encodeTerm dialect cx g (Core.bindingTerm b)) (\bval ->
+          let isClojure = Logic.not supportsLetrec
+              wrappedVal =
+                      Logic.ifElse isClojure (Logic.ifElse isSelfRef (Logic.ifElse isLambda (case bval of
+                        Syntax.ExpressionLambda v0 -> Syntax.ExpressionLambda (Syntax.Lambda {
+                          Syntax.lambdaName = (Just (Syntax.Symbol bname)),
+                          Syntax.lambdaParams = (Syntax.lambdaParams v0),
+                          Syntax.lambdaRestParam = (Syntax.lambdaRestParam v0),
+                          Syntax.lambdaBody = (Syntax.lambdaBody v0)})
+                        _ -> bval) (lispNamedLambdaExpr bname [
+                        "_arg"] (lispApp bval [
+                        lispVar "_arg"]))) bval) (Logic.ifElse (Logic.and isSelfRef (Logic.not isLambda)) (lispLambdaExpr [
+                        "_arg"] (lispApp bval [
+                        lispVar "_arg"])) bval)
+          in (Right (bname, wrappedVal))))) sortedBindings) (\encodedBindings ->
+        let hasSelfRef =
+                Lists.foldl (\acc -> \b -> Logic.or acc (Sets.member (Core.bindingName b) (Variables.freeVariablesInTerm (Core.bindingTerm b)))) False bindings
+            isRecursive = Logic.or hasSelfRef hasCycle
+            letKind =
+                    Logic.ifElse isRecursive Syntax.LetKindRecursive (Logic.ifElse (Equality.lte (Lists.length bindings) 1) Syntax.LetKindParallel Syntax.LetKindSequential)
+            lispBindings =
+                    Lists.map (\eb -> Syntax.LetBindingSimple (Syntax.SimpleBinding {
+                      Syntax.simpleBindingName = (Syntax.Symbol (Pairs.first eb)),
+                      Syntax.simpleBindingValue = (Pairs.second eb)})) encodedBindings
+        in (Right (Syntax.ExpressionLet (Syntax.LetExpression {
+          Syntax.letExpressionKind = letKind,
+          Syntax.letExpressionBindings = lispBindings,
+          Syntax.letExpressionBody = [
+            bodyExpr]}))))))
+
+encodeLiteral :: Core.Literal -> Syntax.Expression
+encodeLiteral lit =
+    case lit of
+      Core.LiteralBoolean v0 -> Syntax.ExpressionLiteral (Syntax.LiteralBoolean v0)
+      Core.LiteralDecimal v0 -> Syntax.ExpressionLiteral (Syntax.LiteralFloat (Syntax.FloatLiteral {
+        Syntax.floatLiteralValue = (Literals.decimalToFloat64 v0),
+        Syntax.floatLiteralPrecision = Nothing}))
+      Core.LiteralString v0 -> Syntax.ExpressionLiteral (Syntax.LiteralString v0)
+      Core.LiteralFloat v0 -> case v0 of
+        Core.FloatValueFloat32 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralFloat (Syntax.FloatLiteral {
+          Syntax.floatLiteralValue = (Literals.float32ToFloat64 v1),
+          Syntax.floatLiteralPrecision = Nothing}))
+        Core.FloatValueFloat64 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralFloat (Syntax.FloatLiteral {
+          Syntax.floatLiteralValue = v1,
+          Syntax.floatLiteralPrecision = Nothing}))
+      Core.LiteralInteger v0 -> case v0 of
+        Core.IntegerValueInt8 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = (Literals.int8ToBigint v1),
+          Syntax.integerLiteralBigint = False}))
+        Core.IntegerValueInt16 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = (Literals.int16ToBigint v1),
+          Syntax.integerLiteralBigint = False}))
+        Core.IntegerValueInt32 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = (Literals.int32ToBigint v1),
+          Syntax.integerLiteralBigint = False}))
+        Core.IntegerValueInt64 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = (Literals.int64ToBigint v1),
+          Syntax.integerLiteralBigint = False}))
+        Core.IntegerValueUint8 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = (Literals.uint8ToBigint v1),
+          Syntax.integerLiteralBigint = False}))
+        Core.IntegerValueUint16 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = (Literals.uint16ToBigint v1),
+          Syntax.integerLiteralBigint = False}))
+        Core.IntegerValueUint32 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = (Literals.uint32ToBigint v1),
+          Syntax.integerLiteralBigint = False}))
+        Core.IntegerValueUint64 v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = (Literals.uint64ToBigint v1),
+          Syntax.integerLiteralBigint = False}))
+        Core.IntegerValueBigint v1 -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+          Syntax.integerLiteralValue = v1,
+          Syntax.integerLiteralBigint = True}))
+      Core.LiteralBinary v0 ->
+        let byteValues = Literals.binaryToBytes v0
+        in (Syntax.ExpressionVector (Syntax.VectorLiteral {
+          Syntax.vectorLiteralElements = (Lists.map (\bv -> Syntax.ExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral {
+            Syntax.integerLiteralValue = (Literals.int32ToBigint bv),
+            Syntax.integerLiteralBigint = False}))) byteValues)}))
+
+encodeProjectionElim :: Syntax.Dialect -> t0 -> Graph.Graph -> Core.Projection -> Maybe Core.Term -> Either t1 Syntax.Expression
+encodeProjectionElim dialect cx g proj marg =
+
+      let fname = Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.projectionFieldName proj))
+          tname = qualifiedSnakeName (Core.projectionTypeName proj)
+      in (Optionals.cases marg (Right (lispLambdaExpr [
+        "__rec"] (Syntax.ExpressionFieldAccess (Syntax.FieldAccess {
+        Syntax.fieldAccessRecordType = (Syntax.Symbol tname),
+        Syntax.fieldAccessField = (Syntax.Symbol fname),
+        Syntax.fieldAccessTarget = (lispVar "__rec")})))) (\arg -> Eithers.bind (encodeTerm dialect cx g arg) (\sarg -> Right (Syntax.ExpressionFieldAccess (Syntax.FieldAccess {
+        Syntax.fieldAccessRecordType = (Syntax.Symbol tname),
+        Syntax.fieldAccessField = (Syntax.Symbol fname),
+        Syntax.fieldAccessTarget = sarg})))))
+
+encodeTerm :: Syntax.Dialect -> t0 -> Graph.Graph -> Core.Term -> Either t1 Syntax.Expression
+encodeTerm dialect cx g term =
+    case term of
+      Core.TermAnnotated v0 -> encodeTerm dialect cx g (Core.annotatedTermBody v0)
+      Core.TermApplication v0 ->
+        let rawFun = Core.applicationFunction v0
+            rawArg = Core.applicationArgument v0
+        in (encodeApplication dialect cx g rawFun rawArg)
+      Core.TermEither v0 -> Eithers.either (\l -> Eithers.bind (encodeTerm dialect cx g l) (\sl -> Right (lispApp (lispVar "list") [
+        lispKeyword "left",
+        sl]))) (\r -> Eithers.bind (encodeTerm dialect cx g r) (\sr -> Right (lispApp (lispVar "list") [
+        lispKeyword "right",
+        sr]))) v0
+      Core.TermLambda v0 -> encodeLambdaTerm dialect cx g v0
+      Core.TermProject v0 -> encodeProjectionElim dialect cx g v0 Nothing
+      Core.TermCases v0 -> encodeUnionElim dialect cx g v0 Nothing
+      Core.TermUnwrap v0 -> encodeUnwrapElim dialect cx g v0 Nothing
+      Core.TermLet v0 ->
+        let bindings = Core.letBindings v0
+            body = Core.letBody v0
+        in (encodeLetAsNative dialect cx g bindings body)
+      Core.TermList v0 -> Eithers.bind (Eithers.mapList (encodeTerm dialect cx g) v0) (\sels -> Right (lispListExpr sels))
+      Core.TermLiteral v0 -> Right (encodeLiteral v0)
+      Core.TermMap v0 -> Eithers.bind (Eithers.mapList (\entry -> Eithers.bind (encodeTerm dialect cx g (Pairs.first entry)) (\k -> Eithers.bind (encodeTerm dialect cx g (Pairs.second entry)) (\v -> Right (Syntax.MapEntry {
+        Syntax.mapEntryKey = k,
+        Syntax.mapEntryValue = v})))) (Maps.toList v0)) (\pairs -> Right (Syntax.ExpressionMap (Syntax.MapLiteral {
+        Syntax.mapLiteralEntries = pairs})))
+      Core.TermOptional v0 -> Optionals.cases v0 (Right (lispApp (lispVar "list") [
+        lispKeyword "none"])) (\val -> Eithers.bind (encodeTerm dialect cx g val) (\sval -> Right (lispApp (lispVar "list") [
+        lispKeyword "given",
+        sval])))
+      Core.TermPair v0 -> Eithers.bind (encodeTerm dialect cx g (Pairs.first v0)) (\f -> Eithers.bind (encodeTerm dialect cx g (Pairs.second v0)) (\s -> Right (lispListExpr [
+        f,
+        s])))
+      Core.TermRecord v0 ->
+        let rname = Core.recordTypeName v0
+            fields = Core.recordFields v0
+        in (Eithers.bind (Eithers.mapList (\f -> encodeTerm dialect cx g (Core.fieldTerm f)) fields) (\sfields ->
+          let constructorName = Strings.cat2 (dialectConstructorPrefix dialect) (qualifiedSnakeName rname)
+          in (Right (lispApp (lispVar constructorName) sfields))))
+      Core.TermSet v0 -> Eithers.bind (Eithers.mapList (encodeTerm dialect cx g) (Sets.toList v0)) (\sels -> Right (Syntax.ExpressionSet (Syntax.SetLiteral {
+        Syntax.setLiteralElements = sels})))
+      Core.TermInject v0 ->
+        let tname = Names.localNameOf (Core.injectionTypeName v0)
+            field = Core.injectionField v0
+            fname = Core.unName (Core.fieldName field)
+            fterm = Core.fieldTerm field
+            dterm = Strip.deannotateTerm fterm
+            isUnit =
+                    case dterm of
+                      Core.TermUnit -> True
+                      Core.TermRecord v1 -> Lists.null (Core.recordFields v1)
+                      _ -> False
+        in (Logic.ifElse isUnit (Right (lispApp (lispVar "list") [
+          lispKeyword (Formatting.convertCaseCamelToLowerSnake fname),
+          lispNilExpr])) (Eithers.bind (encodeTerm dialect cx g fterm) (\sval -> Right (lispApp (lispVar "list") [
+          lispKeyword (Formatting.convertCaseCamelToLowerSnake fname),
+          sval]))))
+      Core.TermUnit -> Right lispNilExpr
+      Core.TermVariable v0 -> Right (lispVar (Formatting.convertCaseCamelOrUnderscoreToLowerSnake (Formatting.sanitizeWithUnderscores Language.lispReservedWords (Core.unName v0))))
+      Core.TermTypeApplication v0 -> encodeTerm dialect cx g (Core.typeApplicationTermBody v0)
+      Core.TermTypeLambda v0 -> encodeTerm dialect cx g (Core.typeLambdaBody v0)
+      Core.TermWrap v0 -> encodeTerm dialect cx g (Core.wrappedTermBody v0)
+
+encodeTermDefinition :: Syntax.Dialect -> t0 -> Graph.Graph -> Packaging.TermDefinition -> Either t1 Syntax.TopLevelFormWithComments
+encodeTermDefinition dialect cx g tdef =
+
+      let name = Packaging.termDefinitionName tdef
+          term = Packaging.termDefinitionBody tdef
+          lname = qualifiedSnakeName name
+          dterm = Strip.deannotateTerm term
+      in case dterm of
+        Core.TermLambda _ -> Eithers.bind (encodeTerm dialect cx g term) (\sterm -> Right (lispTopForm (Syntax.TopLevelFormVariable (Syntax.VariableDefinition {
+          Syntax.variableDefinitionName = (Syntax.Symbol lname),
+          Syntax.variableDefinitionValue = sterm,
+          Syntax.variableDefinitionDoc = Nothing}))))
+        _ -> Eithers.bind (encodeTerm dialect cx g term) (\sterm -> Right (lispTopForm (Syntax.TopLevelFormVariable (Syntax.VariableDefinition {
+          Syntax.variableDefinitionName = (Syntax.Symbol lname),
+          Syntax.variableDefinitionValue = sterm,
+          Syntax.variableDefinitionDoc = Nothing}))))
+
+encodeType :: t0 -> t1 -> Core.Type -> Either t2 Syntax.TypeSpecifier
+encodeType cx g t =
+
+      let typ = Strip.deannotateType t
+      in case typ of
+        Core.TypeAnnotated v0 -> encodeType cx g (Core.annotatedTypeBody v0)
+        Core.TypeApplication v0 -> encodeType cx g (Core.applicationTypeFunction v0)
+        Core.TypeUnit -> Right Syntax.TypeSpecifierUnit
+        Core.TypeLiteral v0 -> Right (case v0 of
+          Core.LiteralTypeBinary -> Syntax.TypeSpecifierNamed (Syntax.Symbol "ByteArray")
+          Core.LiteralTypeBoolean -> Syntax.TypeSpecifierNamed (Syntax.Symbol "Boolean")
+          Core.LiteralTypeDecimal -> Syntax.TypeSpecifierNamed (Syntax.Symbol "Decimal")
+          Core.LiteralTypeFloat _ -> Syntax.TypeSpecifierNamed (Syntax.Symbol "Float")
+          Core.LiteralTypeInteger _ -> Syntax.TypeSpecifierNamed (Syntax.Symbol "Integer")
+          Core.LiteralTypeString -> Syntax.TypeSpecifierNamed (Syntax.Symbol "String"))
+        Core.TypeList v0 -> Eithers.map (\enc -> Syntax.TypeSpecifierList enc) (encodeType cx g v0)
+        Core.TypeSet v0 -> Eithers.map (\enc -> Syntax.TypeSpecifierSet enc) (encodeType cx g v0)
+        Core.TypeMap _ -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol "Map"))
+        Core.TypeOptional v0 -> Eithers.map (\enc -> Syntax.TypeSpecifierMaybe enc) (encodeType cx g v0)
+        Core.TypeEither _ -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol "Either"))
+        Core.TypeEffect v0 -> encodeType cx g v0
+        Core.TypePair _ -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol "Pair"))
+        Core.TypeFunction _ -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol "Function"))
+        Core.TypeRecord _ -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol "Record"))
+        Core.TypeUnion _ -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol "Union"))
+        Core.TypeWrap _ -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol "Wrapper"))
+        Core.TypeVariable v0 -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol (Core.unName v0)))
+        Core.TypeForall v0 -> encodeType cx g (Core.forallTypeBody v0)
+        _ -> Right (Syntax.TypeSpecifierNamed (Syntax.Symbol "Any"))
+
+encodeTypeBody :: String -> Core.Type -> Core.Type -> Either t0 Syntax.TopLevelFormWithComments
+encodeTypeBody lname origTyp typ =
+    case typ of
+      Core.TypeForall v0 -> encodeTypeBody lname origTyp (Core.forallTypeBody v0)
+      Core.TypeRecord v0 ->
+        let fields = Lists.map encodeFieldDef v0
+        in (Right (lispTopForm (Syntax.TopLevelFormRecordType (Syntax.RecordTypeDefinition {
+          Syntax.recordTypeDefinitionName = (Syntax.Symbol lname),
+          Syntax.recordTypeDefinitionFields = fields,
+          Syntax.recordTypeDefinitionDoc = Nothing}))))
+      Core.TypeUnion v0 ->
+        let variantNames =
+                Lists.map (\f -> Syntax.ExpressionLiteral (Syntax.LiteralKeyword (Syntax.Keyword {
+                  Syntax.keywordName = (Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.fieldTypeName f))),
+                  Syntax.keywordNamespace = Nothing}))) v0
+        in (Right (lispTopForm (Syntax.TopLevelFormVariable (Syntax.VariableDefinition {
+          Syntax.variableDefinitionName = (Syntax.Symbol (Strings.cat2 lname "-variants")),
+          Syntax.variableDefinitionValue = (lispListExpr variantNames),
+          Syntax.variableDefinitionDoc = (Just (Syntax.Docstring (Strings.cat2 "Variants of the " lname)))}))))
+      Core.TypeWrap _ -> Right (lispTopForm (Syntax.TopLevelFormRecordType (Syntax.RecordTypeDefinition {
+        Syntax.recordTypeDefinitionName = (Syntax.Symbol lname),
+        Syntax.recordTypeDefinitionFields = [
+          Syntax.FieldDefinition {
+            Syntax.fieldDefinitionName = (Syntax.Symbol "value"),
+            Syntax.fieldDefinitionDefaultValue = Nothing}],
+        Syntax.recordTypeDefinitionDoc = Nothing})))
+      _ -> Right (Syntax.TopLevelFormWithComments {
+        Syntax.topLevelFormWithCommentsDoc = Nothing,
+        Syntax.topLevelFormWithCommentsComment = (Just (Syntax.Comment {
+          Syntax.commentStyle = Syntax.CommentStyleLine,
+          Syntax.commentText = (Strings.cat2 (Strings.cat2 lname " = ") (ShowCore.type_ origTyp))})),
+        Syntax.topLevelFormWithCommentsForm = (Syntax.TopLevelFormExpression (Syntax.ExpressionLiteral Syntax.LiteralNil))})
+
+encodeTypeDefinition :: t0 -> t1 -> Packaging.TypeDefinition -> Either t2 Syntax.TopLevelFormWithComments
+encodeTypeDefinition cx g tdef =
+
+      let name = Packaging.typeDefinitionName tdef
+          typ = Core.typeSchemeBody (Packaging.typeDefinitionBody tdef)
+          lname = qualifiedSnakeName name
+          dtyp = Strip.deannotateType typ
+      in (encodeTypeBody lname typ dtyp)
+
+encodeUnionElim :: Syntax.Dialect -> t0 -> Graph.Graph -> Core.CaseStatement -> Maybe Core.Term -> Either t1 Syntax.Expression
+encodeUnionElim dialect cx g cs marg =
+
+      let tname = Names.localNameOf (Core.caseStatementTypeName cs)
+          caseFields = Core.caseStatementCases cs
+          defCase = Core.caseStatementDefault cs
+      in (Eithers.bind (Eithers.mapList (\cf ->
+        let cfname = Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.caseAlternativeName cf))
+            cfterm = Core.caseAlternativeHandler cf
+            condExpr =
+                    lispApp (lispVar (dialectEqual dialect)) [
+                      lispApp (lispVar (dialectCar dialect)) [
+                        lispVar "match_target"],
+                      (lispKeyword cfname)]
+        in (Eithers.bind (encodeTerm dialect cx g (Core.TermApplication (Core.Application {
+          Core.applicationFunction = cfterm,
+          Core.applicationArgument = (Core.TermVariable (Core.Name "match_value"))}))) (\bodyExpr -> Right (Syntax.CondClause {
+          Syntax.condClauseCondition = condExpr,
+          Syntax.condClauseBody = bodyExpr})))) caseFields) (\clauses -> Eithers.bind (Optionals.cases defCase (Right Nothing) (\dt -> Eithers.bind (encodeTerm dialect cx g dt) (\defBody -> Right (Just defBody)))) (\defExpr ->
+        let condExpr =
+                Syntax.ExpressionCond (Syntax.CondExpression {
+                  Syntax.condExpressionClauses = clauses,
+                  Syntax.condExpressionDefault = defExpr})
+            innerExpr =
+                    lispApp (lispLambdaExpr [
+                      "match_value"] condExpr) [
+                      lispApp (lispVar (dialectCadr dialect)) [
+                        lispVar "match_target"]]
+        in (Optionals.cases marg (Right (lispLambdaExpr [
+          "match_target"] innerExpr)) (\arg -> Eithers.bind (encodeTerm dialect cx g arg) (\sarg -> Right (lispApp (lispLambdaExpr [
+          "match_target"] innerExpr) [
+          sarg])))))))
+
+encodeUnwrapElim :: Syntax.Dialect -> t0 -> Graph.Graph -> Core.Name -> Maybe Core.Term -> Either t1 Syntax.Expression
+encodeUnwrapElim dialect cx g name marg =
+    Optionals.cases marg (Right (lispLambdaExpr [
+      "__rec"] (lispVar "__rec"))) (\arg -> encodeTerm dialect cx g arg)
+
+isPrimitiveRef :: String -> Core.Term -> Bool
+isPrimitiveRef primName term =
+    case term of
+      Core.TermVariable v0 -> Equality.equal (Core.unName v0) primName
+      Core.TermAnnotated v0 -> isPrimitiveRef primName (Core.annotatedTermBody v0)
+      Core.TermTypeApplication v0 -> isPrimitiveRef primName (Core.typeApplicationTermBody v0)
+      Core.TermTypeLambda v0 -> isPrimitiveRef primName (Core.typeLambdaBody v0)
+      _ -> False
+
+lazyFlagsForPrimitiveTerm :: Graph.Graph -> Core.Term -> [Bool]
+lazyFlagsForPrimitiveTerm g headTerm =
+    Optionals.cases (primHeadName headTerm) [] (\name -> Optionals.cases (Maps.lookup name (Graph.graphPrimitives g)) [] (\prim -> Lists.map (\p -> Typing.parameterIsLazy p) (Typing.termSignatureParameters (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim)))))
+
+lispApp :: Syntax.Expression -> [Syntax.Expression] -> Syntax.Expression
+lispApp fun args =
+    Syntax.ExpressionApplication (Syntax.Application {
+      Syntax.applicationFunction = fun,
+      Syntax.applicationArguments = args})
+
+lispKeyword :: String -> Syntax.Expression
+lispKeyword name =
+    Syntax.ExpressionLiteral (Syntax.LiteralKeyword (Syntax.Keyword {
+      Syntax.keywordName = name,
+      Syntax.keywordNamespace = Nothing}))
+
+lispLambdaExpr :: [String] -> Syntax.Expression -> Syntax.Expression
+lispLambdaExpr params body =
+    Syntax.ExpressionLambda (Syntax.Lambda {
+      Syntax.lambdaName = Nothing,
+      Syntax.lambdaParams = (Lists.map (\p -> Syntax.Symbol p) params),
+      Syntax.lambdaRestParam = Nothing,
+      Syntax.lambdaBody = [
+        body]})
+
+lispListExpr :: [Syntax.Expression] -> Syntax.Expression
+lispListExpr elements =
+    Syntax.ExpressionList (Syntax.ListLiteral {
+      Syntax.listLiteralElements = elements,
+      Syntax.listLiteralQuoted = False})
+
+lispLitExpr :: Syntax.Literal -> Syntax.Expression
+lispLitExpr lit = Syntax.ExpressionLiteral lit
+
+lispNamedLambdaExpr :: String -> [String] -> Syntax.Expression -> Syntax.Expression
+lispNamedLambdaExpr name params body =
+    Syntax.ExpressionLambda (Syntax.Lambda {
+      Syntax.lambdaName = (Just (Syntax.Symbol name)),
+      Syntax.lambdaParams = (Lists.map (\p -> Syntax.Symbol p) params),
+      Syntax.lambdaRestParam = Nothing,
+      Syntax.lambdaBody = [
+        body]})
+
+lispNilExpr :: Syntax.Expression
+lispNilExpr = Syntax.ExpressionLiteral Syntax.LiteralNil
+
+lispSymbol :: String -> Syntax.Symbol
+lispSymbol name = Syntax.Symbol name
+
+lispTopForm :: Syntax.TopLevelForm -> Syntax.TopLevelFormWithComments
+lispTopForm form =
+    Syntax.TopLevelFormWithComments {
+      Syntax.topLevelFormWithCommentsDoc = Nothing,
+      Syntax.topLevelFormWithCommentsComment = Nothing,
+      Syntax.topLevelFormWithCommentsForm = form}
+
+lispTopFormWithComments :: Maybe String -> Syntax.TopLevelForm -> Syntax.TopLevelFormWithComments
+lispTopFormWithComments mdoc form =
+    Syntax.TopLevelFormWithComments {
+      Syntax.topLevelFormWithCommentsDoc = (Optionals.map (\d -> Syntax.Docstring d) mdoc),
+      Syntax.topLevelFormWithCommentsComment = Nothing,
+      Syntax.topLevelFormWithCommentsForm = form}
+
+lispVar :: String -> Syntax.Expression
+lispVar name =
+    Syntax.ExpressionVariable (Syntax.VariableReference {
+      Syntax.variableReferenceName = (Syntax.Symbol name),
+      Syntax.variableReferenceFunctionNamespace = False})
+
+moduleExports :: [Syntax.TopLevelFormWithComments] -> [Syntax.ExportDeclaration]
+moduleExports forms =
+
+      let symbols =
+              Lists.concat (Lists.map (\fwc ->
+                let form = Syntax.topLevelFormWithCommentsForm fwc
+                in case form of
+                  Syntax.TopLevelFormVariable v0 -> [
+                    Syntax.variableDefinitionName v0]
+                  Syntax.TopLevelFormRecordType v0 ->
+                    let rname = Syntax.unSymbol (Syntax.recordTypeDefinitionName v0)
+                        fields = Syntax.recordTypeDefinitionFields v0
+                        fieldSyms =
+                                Lists.map (\f ->
+                                  let fn = Syntax.unSymbol (Syntax.fieldDefinitionName f)
+                                  in (Syntax.Symbol (Strings.cat [
+                                    rname,
+                                    "-",
+                                    fn]))) fields
+                    in (Lists.concat [
+                      [
+                        Syntax.Symbol (Strings.cat2 "make-" rname),
+                        (Syntax.Symbol (Strings.cat2 rname "?"))],
+                      fieldSyms])
+                  _ -> []) forms)
+      in (Logic.ifElse (Lists.null symbols) [] [
+        Syntax.ExportDeclaration {
+          Syntax.exportDeclarationSymbols = symbols}])
+
+moduleImports :: Packaging.ModuleName -> [Packaging.Definition] -> [Syntax.ImportDeclaration]
+moduleImports focusNs defs =
+
+      let depNss = Sets.toList (Sets.delete focusNs (Analysis.definitionDependencyModuleNames defs))
+      in (Lists.map (\ns -> Syntax.ImportDeclaration {
+        Syntax.importDeclarationModule = (Syntax.NamespaceName (Packaging.unModuleName ns)),
+        Syntax.importDeclarationSpec = Syntax.ImportSpecAll}) depNss)
+
+moduleToLisp :: Syntax.Dialect -> Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either t1 Syntax.Program
+moduleToLisp dialect mod defs0 cx g =
+
+      let defs = Environment.reorderDefs defs0
+          partitioned = Environment.partitionDefinitions defs
+          allTypeDefs = Pairs.first partitioned
+          termDefs = Pairs.second partitioned
+          typeDefs =
+                  Lists.filter (\td -> Predicates.isNominalType (Core.typeSchemeBody (Packaging.typeDefinitionBody td))) allTypeDefs
+      in (Eithers.bind (Eithers.mapList (encodeTypeDefinition cx g) typeDefs) (\typeItems -> Eithers.bind (Eithers.mapList (encodeTermDefinition dialect cx g) termDefs) (\termItems ->
+        let allItems = Lists.concat2 typeItems termItems
+            nsName = Packaging.unModuleName (Packaging.moduleName mod)
+            focusNs = Packaging.moduleName mod
+            imports = moduleImports focusNs defs
+            exports = moduleExports allItems
+        in (Right (Syntax.Program {
+          Syntax.programDialect = dialect,
+          Syntax.programModule = (Just (Syntax.ModuleDeclaration {
+            Syntax.moduleDeclarationName = (Syntax.NamespaceName nsName),
+            Syntax.moduleDeclarationDoc = Nothing})),
+          Syntax.programImports = imports,
+          Syntax.programExports = exports,
+          Syntax.programForms = allItems})))))
+
+primHeadName :: Core.Term -> Maybe Core.Name
+primHeadName term =
+    case term of
+      Core.TermVariable v0 -> Just v0
+      Core.TermAnnotated v0 -> primHeadName (Core.annotatedTermBody v0)
+      Core.TermTypeApplication v0 -> primHeadName (Core.typeApplicationTermBody v0)
+      Core.TermTypeLambda v0 -> primHeadName (Core.typeLambdaBody v0)
+      _ -> Nothing
+
+primIsLazyAt :: Graph.Graph -> Core.Term -> Int -> Bool
+primIsLazyAt g headTerm i = Optionals.fromOptional False (Lists.maybeAt i (lazyFlagsForPrimitiveTerm g headTerm))
+
+qualifiedSnakeName :: Core.Name -> String
+qualifiedSnakeName name =
+
+      let raw = Core.unName name
+          parts = Strings.splitOn "." raw
+          snakeParts = Lists.map (\p -> Formatting.convertCaseCamelOrUnderscoreToLowerSnake p) parts
+          joined = Strings.intercalate "_" snakeParts
+      in (Formatting.sanitizeWithUnderscores Language.lispReservedWords joined)
+
+qualifiedTypeName :: Core.Name -> String
+qualifiedTypeName name = Formatting.capitalize (Names.localNameOf name)
+
+wrapInThunk :: Syntax.Expression -> Syntax.Expression
+wrapInThunk expr =
+    Syntax.ExpressionLambda (Syntax.Lambda {
+      Syntax.lambdaName = Nothing,
+      Syntax.lambdaParams = [],
+      Syntax.lambdaRestParam = Nothing,
+      Syntax.lambdaBody = [
+        expr]})
diff --git a/src/main/haskell/Hydra/Lisp/Language.hs b/src/main/haskell/Hydra/Lisp/Language.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Lisp/Language.hs
@@ -0,0 +1,346 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Language constraints and reserved words for Lisp (covering Clojure, Emacs Lisp, Common Lisp, and Scheme)
+
+module Hydra.Lisp.Language where
+
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Docs as Docs
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.File as ErrorFile
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Error.System as ErrorSystem
+import qualified Hydra.Errors as Errors
+import qualified Hydra.File as File
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Lexical as Lexical
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.System as System
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Time as Time
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Set as S
+
+-- | Language constraints for Lisp
+lispLanguage :: Coders.Language
+lispLanguage =
+    Coders.Language {
+      Coders.languageName = (Coders.LanguageName "hydra.lisp"),
+      Coders.languageConstraints = Coders.LanguageConstraints {
+        Coders.languageConstraintsLiteralVariants = literalVariants,
+        Coders.languageConstraintsFloatTypes = floatTypes,
+        Coders.languageConstraintsIntegerTypes = integerTypes,
+        Coders.languageConstraintsTermVariants = termVariants,
+        Coders.languageConstraintsTypeVariants = typeVariants,
+        Coders.languageConstraintsTypes = typePredicate},
+      Coders.languageSupportedFeatures = (Sets.fromList [
+        Coders.LanguageFeaturePartialApplication,
+        Coders.LanguageFeatureNestedCaseStatements,
+        Coders.LanguageFeatureNestedPolymorphicLetBindings]),
+      Coders.languageCaseConventions = Coders.CaseConventions {
+        Coders.caseConventionsConstant = Util.CaseConventionUpperSnake,
+        Coders.caseConventionsDirectory = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsEnumValue = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsField = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsFile = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsModule = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsTerm = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsTermVariable = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsType = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsTypeVariable = Util.CaseConventionLowerSnake},
+      Coders.languageDefaultFileExtension = (File.FileExtension "clj")}
+  where
+    literalVariants =
+        Sets.fromList [
+          Variants.LiteralVariantBinary,
+          Variants.LiteralVariantBoolean,
+          Variants.LiteralVariantFloat,
+          Variants.LiteralVariantInteger,
+          Variants.LiteralVariantString]
+    floatTypes = Sets.fromList [
+      Core.FloatTypeFloat64]
+    integerTypes = Sets.fromList [
+      Core.IntegerTypeBigint]
+    termVariants =
+        Sets.fromList [
+          Variants.TermVariantAnnotated,
+          Variants.TermVariantApplication,
+          Variants.TermVariantEither,
+          Variants.TermVariantCases,
+          Variants.TermVariantLambda,
+          Variants.TermVariantProject,
+          Variants.TermVariantUnwrap,
+          Variants.TermVariantTypeApplication,
+          Variants.TermVariantTypeLambda,
+          Variants.TermVariantLet,
+          Variants.TermVariantList,
+          Variants.TermVariantLiteral,
+          Variants.TermVariantMap,
+          Variants.TermVariantOptional,
+          Variants.TermVariantPair,
+          Variants.TermVariantRecord,
+          Variants.TermVariantSet,
+          Variants.TermVariantInject,
+          Variants.TermVariantUnit,
+          Variants.TermVariantVariable,
+          Variants.TermVariantWrap]
+    typeVariants =
+        Sets.fromList [
+          Variants.TypeVariantAnnotated,
+          Variants.TypeVariantApplication,
+          Variants.TypeVariantEither,
+          Variants.TypeVariantEffect,
+          Variants.TypeVariantFunction,
+          Variants.TypeVariantForall,
+          Variants.TypeVariantList,
+          Variants.TypeVariantLiteral,
+          Variants.TypeVariantMap,
+          Variants.TypeVariantOptional,
+          Variants.TypeVariantPair,
+          Variants.TypeVariantRecord,
+          Variants.TypeVariantSet,
+          Variants.TypeVariantUnion,
+          Variants.TypeVariantUnit,
+          Variants.TypeVariantVariable,
+          Variants.TypeVariantVoid,
+          Variants.TypeVariantWrap]
+    typePredicate = \_ -> True
+
+-- | A set of reserved words across all four Lisp dialects
+lispReservedWords :: S.Set String
+lispReservedWords =
+    Sets.fromList (Lists.concat [
+      clojureKeywords,
+      emacsLispKeywords,
+      commonLispKeywords,
+      schemeKeywords,
+      hydraLispKeywords])
+  where
+    clojureKeywords =
+        [
+          "def",
+          "defn",
+          "defn-",
+          "defmacro",
+          "defrecord",
+          "deftype",
+          "defprotocol",
+          "defmulti",
+          "defmethod",
+          "fn",
+          "let",
+          "loop",
+          "recur",
+          "if",
+          "do",
+          "cond",
+          "case",
+          "when",
+          "when-not",
+          "when-let",
+          "if-let",
+          "and",
+          "or",
+          "not",
+          "nil",
+          "true",
+          "false",
+          "throw",
+          "try",
+          "catch",
+          "finally",
+          "quote",
+          "var",
+          "ns",
+          "require",
+          "import",
+          "use",
+          "in-ns",
+          "refer",
+          "new",
+          "set!",
+          "monitor-enter",
+          "monitor-exit"]
+    emacsLispKeywords =
+        [
+          "defun",
+          "defvar",
+          "defconst",
+          "defmacro",
+          "defsubst",
+          "defadvice",
+          "defcustom",
+          "defgroup",
+          "lambda",
+          "let",
+          "let*",
+          "if",
+          "cond",
+          "progn",
+          "prog1",
+          "prog2",
+          "while",
+          "dolist",
+          "dotimes",
+          "and",
+          "or",
+          "not",
+          "nil",
+          "t",
+          "quote",
+          "function",
+          "setq",
+          "setq-default",
+          "require",
+          "provide",
+          "condition-case",
+          "unwind-protect",
+          "save-excursion",
+          "save-restriction",
+          "catch",
+          "throw",
+          "interactive",
+          "cl-defstruct",
+          "cl-case",
+          "cl-loop",
+          "cl-labels",
+          "cl-flet",
+          "pcase",
+          "pcase-let",
+          "seq-let"]
+    commonLispKeywords =
+        [
+          "defun",
+          "defvar",
+          "defparameter",
+          "defconstant",
+          "defmacro",
+          "defgeneric",
+          "defmethod",
+          "defclass",
+          "defstruct",
+          "deftype",
+          "defpackage",
+          "defsetf",
+          "lambda",
+          "let",
+          "let*",
+          "flet",
+          "labels",
+          "macrolet",
+          "symbol-macrolet",
+          "if",
+          "cond",
+          "case",
+          "typecase",
+          "etypecase",
+          "ecase",
+          "progn",
+          "prog1",
+          "prog2",
+          "block",
+          "return-from",
+          "tagbody",
+          "go",
+          "and",
+          "or",
+          "not",
+          "nil",
+          "t",
+          "quote",
+          "function",
+          "setq",
+          "setf",
+          "do",
+          "do*",
+          "dolist",
+          "dotimes",
+          "loop",
+          "values",
+          "multiple-value-bind",
+          "multiple-value-list",
+          "the",
+          "declare",
+          "declaim",
+          "proclaim",
+          "in-package",
+          "use-package",
+          "export",
+          "import",
+          "intern",
+          "handler-case",
+          "handler-bind",
+          "restart-case",
+          "condition",
+          "unwind-protect",
+          "catch",
+          "throw",
+          "eval-when",
+          "load-time-value",
+          "locally",
+          "the",
+          "pi"]
+    schemeKeywords =
+        [
+          "define",
+          "define-syntax",
+          "define-record-type",
+          "define-library",
+          "define-values",
+          "lambda",
+          "let",
+          "let*",
+          "letrec",
+          "letrec*",
+          "let-values",
+          "let*-values",
+          "if",
+          "cond",
+          "case",
+          "when",
+          "unless",
+          "and",
+          "or",
+          "not",
+          "begin",
+          "do",
+          "quote",
+          "quasiquote",
+          "unquote",
+          "unquote-splicing",
+          "set!",
+          "import",
+          "export",
+          "include",
+          "include-ci",
+          "syntax-rules",
+          "syntax-case",
+          "with-syntax",
+          "call-with-current-continuation",
+          "call/cc",
+          "call-with-values",
+          "values",
+          "dynamic-wind",
+          "guard",
+          "parameterize",
+          "else"]
+    hydraLispKeywords = [
+      "Node"]
diff --git a/src/main/haskell/Hydra/Lisp/Serde.hs b/src/main/haskell/Hydra/Lisp/Serde.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Lisp/Serde.hs
@@ -0,0 +1,1097 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Lisp serializer: converts Lisp AST to concrete syntax for Clojure, Emacs Lisp, Common Lisp, or Scheme
+
+module Hydra.Lisp.Serde where
+
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Constants as Constants
+import qualified Hydra.Core as Core
+import qualified Hydra.Docs as Docs
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.File as ErrorFile
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Error.System as ErrorSystem
+import qualified Hydra.Errors as Errors
+import qualified Hydra.File as File
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Lisp.Syntax as Syntax
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Serialization as Serialization
+import qualified Hydra.System as System
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Time as Time
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+andExpressionToExpr :: Syntax.Dialect -> Syntax.AndExpression -> Ast.Expr
+andExpressionToExpr d andExpr =
+    Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+      Serialization.cst "and"] (Lists.map (expressionToExpr d) (Syntax.andExpressionExpressions andExpr))))
+
+applicationToExpr :: Syntax.Dialect -> Syntax.Application -> Ast.Expr
+applicationToExpr d app =
+
+      let funExpr = Syntax.applicationFunction app
+          fun = expressionToExpr d funExpr
+          args = Lists.map (expressionToExpr d) (Syntax.applicationArguments app)
+          funcallWhenComputed =
+                  case funExpr of
+                    Syntax.ExpressionVariable _ -> False
+                    _ -> True
+          needsFuncall =
+                  case d of
+                    Syntax.DialectCommonLisp -> funcallWhenComputed
+                    Syntax.DialectEmacsLisp -> funcallWhenComputed
+                    _ -> False
+          allParts =
+                  Logic.ifElse needsFuncall (Lists.concat2 [
+                    Serialization.cst "funcall",
+                    fun] args) (Lists.concat2 [
+                    fun] args)
+      in (Serialization.parens (Serialization.spaceSepAdaptive allParts))
+
+caseExpressionToExpr :: Syntax.Dialect -> Syntax.CaseExpression -> Ast.Expr
+caseExpressionToExpr d caseExpr =
+
+      let scrutinee = expressionToExpr d (Syntax.caseExpressionScrutinee caseExpr)
+          clauses = Syntax.caseExpressionClauses caseExpr
+          dflt = Syntax.caseExpressionDefault caseExpr
+          clauseExprs =
+                  Lists.map (\c -> Serialization.parens (Serialization.spaceSepAdaptive [
+                    Serialization.parens (Serialization.spaceSepAdaptive (Lists.map (expressionToExpr d) (Syntax.caseClauseKeys c))),
+                    (expressionToExpr d (Syntax.caseClauseBody c))])) clauses
+          defaultPart =
+                  Optionals.cases dflt [] (\e -> [
+                    Serialization.parens (Serialization.spaceSepAdaptive [
+                      Serialization.cst "else",
+                      (expressionToExpr d e)])])
+      in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+        [
+          Serialization.cst "case",
+          scrutinee],
+        clauseExprs,
+        defaultPart])))
+
+commentToExpr :: Syntax.Comment -> Ast.Expr
+commentToExpr c =
+
+      let text = Syntax.commentText c
+      in (Serialization.cst (Logic.ifElse (Equality.equal text "") ";" (Strings.cat2 "; " text)))
+
+condExpressionToExpr :: Syntax.Dialect -> Syntax.CondExpression -> Ast.Expr
+condExpressionToExpr d condExpr =
+
+      let clauses = Syntax.condExpressionClauses condExpr
+          dflt = Syntax.condExpressionDefault condExpr
+      in case d of
+        Syntax.DialectClojure ->
+          let clauseExprs =
+                  Lists.concat (Lists.map (\c -> [
+                    expressionToExpr d (Syntax.condClauseCondition c),
+                    (expressionToExpr d (Syntax.condClauseBody c))]) clauses)
+              defaultPart =
+                      Optionals.cases dflt [] (\e -> [
+                        Serialization.cst ":else",
+                        (expressionToExpr d e)])
+          in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst "cond"],
+            clauseExprs,
+            defaultPart])))
+        Syntax.DialectEmacsLisp ->
+          let clauseExprs =
+                  Lists.map (\c -> Serialization.parens (Serialization.spaceSepAdaptive [
+                    expressionToExpr d (Syntax.condClauseCondition c),
+                    (expressionToExpr d (Syntax.condClauseBody c))])) clauses
+              defaultPart =
+                      Optionals.cases dflt [] (\e -> [
+                        Serialization.parens (Serialization.spaceSepAdaptive [
+                          Serialization.cst "t",
+                          (expressionToExpr d e)])])
+          in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst "cond"],
+            clauseExprs,
+            defaultPart])))
+        Syntax.DialectCommonLisp ->
+          let clauseExprs =
+                  Lists.map (\c -> Serialization.parens (Serialization.spaceSepAdaptive [
+                    expressionToExpr d (Syntax.condClauseCondition c),
+                    (expressionToExpr d (Syntax.condClauseBody c))])) clauses
+              defaultPart =
+                      Optionals.cases dflt [] (\e -> [
+                        Serialization.parens (Serialization.spaceSepAdaptive [
+                          Serialization.cst "t",
+                          (expressionToExpr d e)])])
+          in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst "cond"],
+            clauseExprs,
+            defaultPart])))
+        Syntax.DialectScheme ->
+          let clauseExprs =
+                  Lists.map (\c -> Serialization.parens (Serialization.spaceSepAdaptive [
+                    expressionToExpr d (Syntax.condClauseCondition c),
+                    (expressionToExpr d (Syntax.condClauseBody c))])) clauses
+              defaultPart =
+                      Optionals.cases dflt [] (\e -> [
+                        Serialization.parens (Serialization.spaceSepAdaptive [
+                          Serialization.cst "else",
+                          (expressionToExpr d e)])])
+          in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst "cond"],
+            clauseExprs,
+            defaultPart])))
+
+constantDefinitionToExpr :: Syntax.Dialect -> Syntax.ConstantDefinition -> Ast.Expr
+constantDefinitionToExpr d cdef =
+
+      let name = symbolToExpr (Syntax.constantDefinitionName cdef)
+          value = expressionToExpr d (Syntax.constantDefinitionValue cdef)
+      in (Serialization.parens (Serialization.spaceSepAdaptive [
+        Serialization.cst (defconstKeyword d),
+        name,
+        value]))
+
+defKeyword :: Syntax.Dialect -> String
+defKeyword d =
+    case d of
+      Syntax.DialectClojure -> "def"
+      Syntax.DialectEmacsLisp -> "defvar"
+      Syntax.DialectCommonLisp -> "cl:defvar"
+      Syntax.DialectScheme -> "define"
+
+defconstKeyword :: Syntax.Dialect -> String
+defconstKeyword d =
+    case d of
+      Syntax.DialectClojure -> "def"
+      Syntax.DialectEmacsLisp -> "defconst"
+      Syntax.DialectCommonLisp -> "cl:defconstant"
+      Syntax.DialectScheme -> "define"
+
+defnKeyword :: Syntax.Dialect -> String
+defnKeyword d =
+    case d of
+      Syntax.DialectClojure -> "defn"
+      Syntax.DialectEmacsLisp -> "defun"
+      Syntax.DialectCommonLisp -> "cl:defun"
+      Syntax.DialectScheme -> "define"
+
+defrecordKeyword :: Syntax.Dialect -> String
+defrecordKeyword d =
+    case d of
+      Syntax.DialectClojure -> "defrecord"
+      Syntax.DialectEmacsLisp -> "cl-defstruct"
+      Syntax.DialectCommonLisp -> "cl:defstruct"
+      Syntax.DialectScheme -> "define-record-type"
+
+doExpressionToExpr :: Syntax.Dialect -> Syntax.DoExpression -> Ast.Expr
+doExpressionToExpr d doExpr =
+
+      let kw =
+              case d of
+                Syntax.DialectClojure -> "do"
+                Syntax.DialectEmacsLisp -> "progn"
+                Syntax.DialectCommonLisp -> "progn"
+                Syntax.DialectScheme -> "begin"
+      in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+        Serialization.cst kw] (Lists.map (expressionToExpr d) (Syntax.doExpressionExpressions doExpr)))))
+
+docstringToExpr :: Syntax.Docstring -> Ast.Expr
+docstringToExpr ds =
+
+      let text = Syntax.unDocstring ds
+      in (Serialization.cst (Logic.ifElse (Equality.equal text "") ";;" (Strings.cat [
+        ";; ",
+        text])))
+
+exportDeclarationToExpr :: Syntax.Dialect -> Syntax.ExportDeclaration -> Ast.Expr
+exportDeclarationToExpr d edecl =
+
+      let syms = Lists.map symbolToExpr (Syntax.exportDeclarationSymbols edecl)
+      in case d of
+        Syntax.DialectClojure -> Serialization.cst ""
+        Syntax.DialectEmacsLisp -> Serialization.newlineSep (Lists.map (\s -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.cst "provide",
+          (Serialization.noSep [
+            Serialization.cst "'",
+            s])])) syms)
+        Syntax.DialectCommonLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+          Serialization.cst ":export"] (Lists.map (\s -> Serialization.noSep [
+          Serialization.cst ":",
+          s]) syms)))
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+          Serialization.cst "export"] syms))
+
+expressionToExpr :: Syntax.Dialect -> Syntax.Expression -> Ast.Expr
+expressionToExpr d expr =
+    case expr of
+      Syntax.ExpressionApplication v0 -> applicationToExpr d v0
+      Syntax.ExpressionLambda v0 -> lambdaToExpr d v0
+      Syntax.ExpressionLet v0 -> letExpressionToExpr d v0
+      Syntax.ExpressionIf v0 -> ifExpressionToExpr d v0
+      Syntax.ExpressionCond v0 -> condExpressionToExpr d v0
+      Syntax.ExpressionCase v0 -> caseExpressionToExpr d v0
+      Syntax.ExpressionAnd v0 -> andExpressionToExpr d v0
+      Syntax.ExpressionOr v0 -> orExpressionToExpr d v0
+      Syntax.ExpressionNot v0 -> notExpressionToExpr d v0
+      Syntax.ExpressionDo v0 -> doExpressionToExpr d v0
+      Syntax.ExpressionBegin v0 -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+        Serialization.cst "begin"] (Lists.map (expressionToExpr d) (Syntax.beginExpressionExpressions v0))))
+      Syntax.ExpressionVariable v0 -> variableReferenceToExpr d v0
+      Syntax.ExpressionLiteral v0 -> literalToExpr d v0
+      Syntax.ExpressionList v0 -> listLiteralToExpr d v0
+      Syntax.ExpressionVector v0 -> vectorLiteralToExpr d v0
+      Syntax.ExpressionMap v0 -> mapLiteralToExpr d v0
+      Syntax.ExpressionSet v0 -> setLiteralToExpr d v0
+      Syntax.ExpressionCons v0 -> Serialization.parens (Serialization.spaceSepAdaptive [
+        Serialization.cst "cons",
+        (expressionToExpr d (Syntax.consExpressionHead v0)),
+        (expressionToExpr d (Syntax.consExpressionTail v0))])
+      Syntax.ExpressionDottedPair v0 -> Serialization.parens (Serialization.spaceSepAdaptive [
+        expressionToExpr d (Syntax.dottedPairCar v0),
+        (Serialization.cst "."),
+        (expressionToExpr d (Syntax.dottedPairCdr v0))])
+      Syntax.ExpressionFieldAccess v0 -> fieldAccessToExpr d v0
+      Syntax.ExpressionTypeAnnotation v0 -> expressionToExpr d (Syntax.typeAnnotationExpression v0)
+      Syntax.ExpressionQuote v0 -> Serialization.noSep [
+        Serialization.cst "'",
+        (expressionToExpr d (Syntax.quoteExpressionBody v0))]
+      Syntax.ExpressionQuasiquote v0 -> Serialization.noSep [
+        Serialization.cst "`",
+        (expressionToExpr d (Syntax.quasiquoteExpressionBody v0))]
+      Syntax.ExpressionUnquote v0 -> case d of
+        Syntax.DialectClojure -> Serialization.noSep [
+          Serialization.cst "~",
+          (expressionToExpr d (Syntax.unquoteExpressionBody v0))]
+        Syntax.DialectEmacsLisp -> Serialization.noSep [
+          Serialization.cst ",",
+          (expressionToExpr d (Syntax.unquoteExpressionBody v0))]
+        Syntax.DialectCommonLisp -> Serialization.noSep [
+          Serialization.cst ",",
+          (expressionToExpr d (Syntax.unquoteExpressionBody v0))]
+        Syntax.DialectScheme -> Serialization.noSep [
+          Serialization.cst ",",
+          (expressionToExpr d (Syntax.unquoteExpressionBody v0))]
+      Syntax.ExpressionSplicingUnquote v0 -> case d of
+        Syntax.DialectClojure -> Serialization.noSep [
+          Serialization.cst "~@",
+          (expressionToExpr d (Syntax.splicingUnquoteExpressionBody v0))]
+        Syntax.DialectEmacsLisp -> Serialization.noSep [
+          Serialization.cst ",@",
+          (expressionToExpr d (Syntax.splicingUnquoteExpressionBody v0))]
+        Syntax.DialectCommonLisp -> Serialization.noSep [
+          Serialization.cst ",@",
+          (expressionToExpr d (Syntax.splicingUnquoteExpressionBody v0))]
+        Syntax.DialectScheme -> Serialization.noSep [
+          Serialization.cst ",@",
+          (expressionToExpr d (Syntax.splicingUnquoteExpressionBody v0))]
+      Syntax.ExpressionSExpression v0 -> sExpressionToExpr v0
+
+falseExpr :: Syntax.Dialect -> Ast.Expr
+falseExpr d =
+    case d of
+      Syntax.DialectClojure -> Serialization.cst "false"
+      Syntax.DialectEmacsLisp -> Serialization.cst "nil"
+      Syntax.DialectCommonLisp -> Serialization.cst "cl:nil"
+      Syntax.DialectScheme -> Serialization.cst "#f"
+
+fieldAccessToExpr :: Syntax.Dialect -> Syntax.FieldAccess -> Ast.Expr
+fieldAccessToExpr d fa =
+
+      let rtype = symbolToExpr (Syntax.fieldAccessRecordType fa)
+          field = symbolToExpr (Syntax.fieldAccessField fa)
+          target = expressionToExpr d (Syntax.fieldAccessTarget fa)
+      in case d of
+        Syntax.DialectClojure -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.noSep [
+            Serialization.cst ":",
+            field],
+          target])
+        Syntax.DialectEmacsLisp -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.noSep [
+            rtype,
+            (Serialization.cst "-"),
+            field],
+          target])
+        Syntax.DialectCommonLisp -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.noSep [
+            rtype,
+            (Serialization.cst "-"),
+            field],
+          target])
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.noSep [
+            rtype,
+            (Serialization.cst "-"),
+            field],
+          target])
+
+formatLispFloat :: Syntax.Dialect -> Double -> String
+formatLispFloat d v =
+
+      let s = Literals.showFloat64 v
+      in (Logic.ifElse (Equality.equal s "NaN") (case d of
+        Syntax.DialectClojure -> "Double/NaN"
+        Syntax.DialectScheme -> "+nan.0"
+        Syntax.DialectCommonLisp -> "+hydra-nan+"
+        Syntax.DialectEmacsLisp -> "0.0e+NaN") (Logic.ifElse (Equality.equal s "Infinity") (case d of
+        Syntax.DialectClojure -> "Double/POSITIVE_INFINITY"
+        Syntax.DialectScheme -> "+inf.0"
+        Syntax.DialectCommonLisp -> "+hydra-pos-inf+"
+        Syntax.DialectEmacsLisp -> "1.0e+INF") (Logic.ifElse (Equality.equal s "-Infinity") (case d of
+        Syntax.DialectClojure -> "Double/NEGATIVE_INFINITY"
+        Syntax.DialectScheme -> "-inf.0"
+        Syntax.DialectCommonLisp -> "+hydra-neg-inf+"
+        Syntax.DialectEmacsLisp -> "-1.0e+INF") s)))
+
+functionDefinitionToExpr :: Syntax.Dialect -> Syntax.FunctionDefinition -> Ast.Expr
+functionDefinitionToExpr d fdef =
+
+      let name = symbolToExpr (Syntax.functionDefinitionName fdef)
+          params = Lists.map symbolToExpr (Syntax.functionDefinitionParams fdef)
+          body = Lists.map (expressionToExpr d) (Syntax.functionDefinitionBody fdef)
+      in case d of
+        Syntax.DialectClojure -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "defn",
+            name],
+          [
+            Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep params)],
+          body]))
+        Syntax.DialectEmacsLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "defun",
+            name],
+          [
+            Serialization.parens (Serialization.spaceSepAdaptive params)],
+          body]))
+        Syntax.DialectCommonLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "defun",
+            name],
+          [
+            Serialization.parens (Serialization.spaceSepAdaptive params)],
+          body]))
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "define"],
+          [
+            Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+              name] params))],
+          body]))
+
+ifExpressionToExpr :: Syntax.Dialect -> Syntax.IfExpression -> Ast.Expr
+ifExpressionToExpr d ifExpr =
+
+      let cond = expressionToExpr d (Syntax.ifExpressionCondition ifExpr)
+          then_ = expressionToExpr d (Syntax.ifExpressionThen ifExpr)
+          else_ = Syntax.ifExpressionElse ifExpr
+          elsePart = Optionals.cases else_ [] (\e -> [
+                expressionToExpr d e])
+      in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+        [
+          Serialization.cst "if",
+          cond,
+          then_],
+        elsePart])))
+
+importDeclarationToExpr :: Syntax.Dialect -> Syntax.ImportDeclaration -> Ast.Expr
+importDeclarationToExpr d idecl =
+
+      let modName = Syntax.unNamespaceName (Syntax.importDeclarationModule idecl)
+      in case d of
+        Syntax.DialectClojure -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.cst ":require",
+          (Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep [
+            Serialization.cst modName]))])
+        Syntax.DialectEmacsLisp -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.cst "require",
+          (Serialization.noSep [
+            Serialization.cst "'",
+            (Serialization.cst modName)])])
+        Syntax.DialectCommonLisp -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.cst ":use",
+          (Serialization.cst (Strings.cat2 ":" modName))])
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.cst "import",
+          (Serialization.parens (Serialization.cst modName))])
+
+keywordToExpr :: Syntax.Dialect -> Syntax.Keyword -> Ast.Expr
+keywordToExpr d k =
+
+      let name = Syntax.keywordName k
+          ns = Syntax.keywordNamespace k
+      in case d of
+        Syntax.DialectScheme -> Serialization.noSep [
+          Serialization.cst "'",
+          (Serialization.cst name)]
+        _ -> Serialization.cst (Optionals.cases ns (Strings.cat2 ":" name) (\n -> Strings.cat [
+          n,
+          "/:",
+          name]))
+
+lambdaKeyword :: Syntax.Dialect -> String
+lambdaKeyword d =
+    case d of
+      Syntax.DialectClojure -> "fn"
+      Syntax.DialectEmacsLisp -> "lambda"
+      Syntax.DialectCommonLisp -> "cl:lambda"
+      Syntax.DialectScheme -> "lambda"
+
+lambdaToExpr :: Syntax.Dialect -> Syntax.Lambda -> Ast.Expr
+lambdaToExpr d lam =
+
+      let params = Lists.map symbolToExpr (Syntax.lambdaParams lam)
+          body = Lists.map (expressionToExpr d) (Syntax.lambdaBody lam)
+          mname = Syntax.lambdaName lam
+          kw = lambdaKeyword d
+      in case d of
+        Syntax.DialectClojure -> Optionals.cases mname (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst kw],
+          [
+            Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep params)],
+          body]))) (\sym -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst kw,
+            (symbolToExpr sym)],
+          [
+            Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep params)],
+          body])))
+        Syntax.DialectEmacsLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst kw],
+          [
+            Serialization.parens (Serialization.spaceSepAdaptive params)],
+          body]))
+        Syntax.DialectCommonLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst kw],
+          [
+            Serialization.parens (Serialization.spaceSepAdaptive params)],
+          body]))
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst kw],
+          [
+            Serialization.parens (Serialization.spaceSepAdaptive params)],
+          body]))
+
+letExpressionToExpr :: Syntax.Dialect -> Syntax.LetExpression -> Ast.Expr
+letExpressionToExpr d letExpr =
+
+      let kind = Syntax.letExpressionKind letExpr
+          bindings = Syntax.letExpressionBindings letExpr
+          body = Lists.map (expressionToExpr d) (Syntax.letExpressionBody letExpr)
+          bindingPairs =
+                  Lists.map (\b -> case b of
+                    Syntax.LetBindingSimple v0 -> (symbolToExpr (Syntax.simpleBindingName v0), (expressionToExpr d (Syntax.simpleBindingValue v0)))
+                    Syntax.LetBindingDestructuring _ -> (Serialization.cst "<destructuring>", (Serialization.cst "<destructuring>"))) bindings
+      in case d of
+        Syntax.DialectClojure -> case kind of
+          Syntax.LetKindRecursive ->
+            let fnSpecs =
+                    Lists.map (\b -> case b of
+                      Syntax.LetBindingSimple v2 ->
+                        let name = symbolToExpr (Syntax.simpleBindingName v2)
+                            val = Syntax.simpleBindingValue v2
+                        in case val of
+                          Syntax.ExpressionLambda v3 ->
+                            let params = Lists.map symbolToExpr (Syntax.lambdaParams v3)
+                                lbody = Lists.map (expressionToExpr d) (Syntax.lambdaBody v3)
+                            in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+                              [
+                                name],
+                              [
+                                Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep params)],
+                              lbody])))
+                          _ -> Serialization.parens (Serialization.spaceSepAdaptive [
+                            name,
+                            (expressionToExpr d val)])
+                      Syntax.LetBindingDestructuring _ -> Serialization.cst "<destructuring>") bindings
+            in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+              [
+                Serialization.cst "letfn"],
+              [
+                Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep fnSpecs)],
+              body])))
+          Syntax.LetKindParallel -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst "let"],
+            [
+              Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep (Lists.concat (Lists.map (\p -> [
+                Pairs.first p,
+                (Pairs.second p)]) bindingPairs)))],
+            body]))
+          Syntax.LetKindSequential -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst "let"],
+            [
+              Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep (Lists.concat (Lists.map (\p -> [
+                Pairs.first p,
+                (Pairs.second p)]) bindingPairs)))],
+            body]))
+        Syntax.DialectEmacsLisp ->
+          let kw =
+                  case kind of
+                    Syntax.LetKindParallel -> "let"
+                    Syntax.LetKindSequential -> "let*"
+                    Syntax.LetKindRecursive -> "letrec"
+              bindingExprs =
+                      Lists.map (\p -> Serialization.parens (Serialization.spaceSepAdaptive [
+                        Pairs.first p,
+                        (Pairs.second p)])) bindingPairs
+          in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst kw],
+            [
+              Serialization.parens (Serialization.spaceSepAdaptive bindingExprs)],
+            body])))
+        Syntax.DialectCommonLisp ->
+          let kw =
+                  case kind of
+                    Syntax.LetKindParallel -> "let"
+                    Syntax.LetKindSequential -> "let*"
+                    Syntax.LetKindRecursive -> "letrec"
+              bindingExprs =
+                      Lists.map (\p -> Serialization.parens (Serialization.spaceSepAdaptive [
+                        Pairs.first p,
+                        (Pairs.second p)])) bindingPairs
+          in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst kw],
+            [
+              Serialization.parens (Serialization.spaceSepAdaptive bindingExprs)],
+            body])))
+        Syntax.DialectScheme ->
+          let kw =
+                  case kind of
+                    Syntax.LetKindParallel -> "let"
+                    Syntax.LetKindSequential -> "let*"
+                    Syntax.LetKindRecursive -> "letrec"
+              bindingExprs =
+                      Lists.map (\p -> Serialization.parens (Serialization.spaceSepAdaptive [
+                        Pairs.first p,
+                        (Pairs.second p)])) bindingPairs
+          in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst kw],
+            [
+              Serialization.parens (Serialization.spaceSepAdaptive bindingExprs)],
+            body])))
+
+listKeyword :: Syntax.Dialect -> String
+listKeyword d =
+    case d of
+      Syntax.DialectClojure -> "list"
+      Syntax.DialectEmacsLisp -> "list"
+      Syntax.DialectCommonLisp -> "cl:list"
+      Syntax.DialectScheme -> "list"
+
+listLiteralToExpr :: Syntax.Dialect -> Syntax.ListLiteral -> Ast.Expr
+listLiteralToExpr d ll =
+
+      let elems = Lists.map (expressionToExpr d) (Syntax.listLiteralElements ll)
+          quoted = Syntax.listLiteralQuoted ll
+      in (Logic.ifElse quoted (Serialization.noSep [
+        Serialization.cst "'",
+        (Serialization.parens (Serialization.spaceSepAdaptive elems))]) (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+        Serialization.cst (listKeyword d)] elems))))
+
+literalToExpr :: Syntax.Dialect -> Syntax.Literal -> Ast.Expr
+literalToExpr d lit =
+    case lit of
+      Syntax.LiteralInteger v0 -> Serialization.cst (Literals.showBigint (Syntax.integerLiteralValue v0))
+      Syntax.LiteralFloat v0 -> Serialization.cst (formatLispFloat d (Syntax.floatLiteralValue v0))
+      Syntax.LiteralString v0 ->
+        let e1 = Strings.intercalate "\\\\" (Strings.splitOn "\\" v0)
+        in case d of
+          Syntax.DialectCommonLisp ->
+            let escaped = Strings.intercalate "\\\"" (Strings.splitOn "\"" e1)
+            in (Serialization.cst (Strings.cat [
+              "\"",
+              escaped,
+              "\""]))
+          Syntax.DialectClojure ->
+            let e2 = Strings.intercalate "\\n" (Strings.splitOn (Strings.fromList [
+                  10]) e1)
+                e3 = Strings.intercalate "\\r" (Strings.splitOn (Strings.fromList [
+                      13]) e2)
+                e4 = Strings.intercalate "\\t" (Strings.splitOn (Strings.fromList [
+                      9]) e3)
+                escaped = Strings.intercalate "\\\"" (Strings.splitOn "\"" e4)
+            in (Serialization.cst (Strings.cat [
+              "\"",
+              escaped,
+              "\""]))
+          Syntax.DialectEmacsLisp ->
+            let e2 = Strings.intercalate "\\n" (Strings.splitOn (Strings.fromList [
+                  10]) e1)
+                e3 = Strings.intercalate "\\r" (Strings.splitOn (Strings.fromList [
+                      13]) e2)
+                e4 = Strings.intercalate "\\t" (Strings.splitOn (Strings.fromList [
+                      9]) e3)
+                escaped = Strings.intercalate "\\\"" (Strings.splitOn "\"" e4)
+            in (Serialization.cst (Strings.cat [
+              "\"",
+              escaped,
+              "\""]))
+          Syntax.DialectScheme ->
+            let e2 = Strings.intercalate "\\n" (Strings.splitOn (Strings.fromList [
+                  10]) e1)
+                e3 = Strings.intercalate "\\r" (Strings.splitOn (Strings.fromList [
+                      13]) e2)
+                e4 = Strings.intercalate "\\t" (Strings.splitOn (Strings.fromList [
+                      9]) e3)
+                escaped = Strings.intercalate "\\\"" (Strings.splitOn "\"" e4)
+            in (Serialization.cst (Strings.cat [
+              "\"",
+              escaped,
+              "\""]))
+      Syntax.LiteralCharacter v0 ->
+        let ch = Syntax.characterLiteralValue v0
+        in case d of
+          Syntax.DialectClojure -> Serialization.cst (Strings.cat2 "\\" ch)
+          Syntax.DialectEmacsLisp -> Serialization.cst (Strings.cat2 "?" ch)
+          Syntax.DialectCommonLisp -> Serialization.cst (Strings.cat2 "#\\" ch)
+          Syntax.DialectScheme -> Serialization.cst (Strings.cat2 "#\\" ch)
+      Syntax.LiteralBoolean v0 -> Logic.ifElse v0 (trueExpr d) (falseExpr d)
+      Syntax.LiteralNil -> nilExpr d
+      Syntax.LiteralKeyword v0 -> keywordToExpr d v0
+      Syntax.LiteralSymbol v0 -> Serialization.noSep [
+        Serialization.cst "'",
+        (symbolToExpr v0)]
+
+macroDefinitionToExpr :: Syntax.Dialect -> Syntax.MacroDefinition -> Ast.Expr
+macroDefinitionToExpr d mdef =
+
+      let name = symbolToExpr (Syntax.macroDefinitionName mdef)
+          params = Lists.map symbolToExpr (Syntax.macroDefinitionParams mdef)
+          body = Lists.map (expressionToExpr d) (Syntax.macroDefinitionBody mdef)
+      in case d of
+        Syntax.DialectClojure -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "defmacro",
+            name],
+          [
+            Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep params)],
+          body]))
+        Syntax.DialectEmacsLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "defmacro",
+            name],
+          [
+            Serialization.parens (Serialization.spaceSepAdaptive params)],
+          body]))
+        Syntax.DialectCommonLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "defmacro",
+            name],
+          [
+            Serialization.parens (Serialization.spaceSepAdaptive params)],
+          body]))
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "define-syntax",
+            name],
+          body]))
+
+mapLiteralToExpr :: Syntax.Dialect -> Syntax.MapLiteral -> Ast.Expr
+mapLiteralToExpr d ml =
+
+      let entries = Syntax.mapLiteralEntries ml
+      in case d of
+        Syntax.DialectClojure -> Serialization.brackets Serialization.curlyBraces Serialization.inlineStyle (Serialization.spaceSep (Lists.concat (Lists.map (\e -> [
+          expressionToExpr d (Syntax.mapEntryKey e),
+          (expressionToExpr d (Syntax.mapEntryValue e))]) entries)))
+        Syntax.DialectEmacsLisp -> Serialization.noSep [
+          Serialization.cst "'",
+          (Serialization.parens (Serialization.spaceSepAdaptive (Lists.map (\e -> Serialization.parens (Serialization.spaceSepAdaptive [
+            expressionToExpr d (Syntax.mapEntryKey e),
+            (Serialization.cst "."),
+            (expressionToExpr d (Syntax.mapEntryValue e))])) entries)))]
+        Syntax.DialectCommonLisp -> Serialization.noSep [
+          Serialization.cst "'",
+          (Serialization.parens (Serialization.spaceSepAdaptive (Lists.map (\e -> Serialization.parens (Serialization.spaceSepAdaptive [
+            expressionToExpr d (Syntax.mapEntryKey e),
+            (Serialization.cst "."),
+            (expressionToExpr d (Syntax.mapEntryValue e))])) entries)))]
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+          Serialization.cst "list"] (Lists.map (\e -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.cst "cons",
+          (expressionToExpr d (Syntax.mapEntryKey e)),
+          (expressionToExpr d (Syntax.mapEntryValue e))])) entries)))
+
+moduleDeclarationToExpr :: Syntax.Dialect -> Syntax.ModuleDeclaration -> Ast.Expr
+moduleDeclarationToExpr d mdecl =
+
+      let name = Syntax.unNamespaceName (Syntax.moduleDeclarationName mdecl)
+      in case d of
+        Syntax.DialectClojure -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.cst "ns",
+          (Serialization.cst name)])
+        Syntax.DialectEmacsLisp -> Serialization.newlineSep [
+          Serialization.parens (Serialization.spaceSepAdaptive [
+            Serialization.cst "require",
+            (Serialization.noSep [
+              Serialization.cst "'",
+              (Serialization.cst "cl-lib")])]),
+          (Serialization.parens (Serialization.spaceSepAdaptive [
+            Serialization.cst "provide",
+            (Serialization.noSep [
+              Serialization.cst "'",
+              (Serialization.cst name)])]))]
+        Syntax.DialectCommonLisp -> Serialization.newlineSep [
+          Serialization.parens (Serialization.spaceSepAdaptive [
+            Serialization.cst "defpackage",
+            (Serialization.cst (Strings.cat2 ":" name))]),
+          (Serialization.parens (Serialization.spaceSepAdaptive [
+            Serialization.cst "in-package",
+            (Serialization.cst (Strings.cat2 ":" name))]))]
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive [
+          Serialization.cst "define-library",
+          (Serialization.parens (Serialization.cst name))])
+
+nilExpr :: Syntax.Dialect -> Ast.Expr
+nilExpr d =
+    case d of
+      Syntax.DialectClojure -> Serialization.cst "nil"
+      Syntax.DialectEmacsLisp -> Serialization.cst "nil"
+      Syntax.DialectCommonLisp -> Serialization.cst "cl:nil"
+      Syntax.DialectScheme -> Serialization.cst "'()"
+
+notExpressionToExpr :: Syntax.Dialect -> Syntax.NotExpression -> Ast.Expr
+notExpressionToExpr d notExpr =
+    Serialization.parens (Serialization.spaceSepAdaptive [
+      Serialization.cst "not",
+      (expressionToExpr d (Syntax.notExpressionExpression notExpr))])
+
+orExpressionToExpr :: Syntax.Dialect -> Syntax.OrExpression -> Ast.Expr
+orExpressionToExpr d orExpr =
+    Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+      Serialization.cst "or"] (Lists.map (expressionToExpr d) (Syntax.orExpressionExpressions orExpr))))
+
+programToExpr :: Syntax.Program -> Ast.Expr
+programToExpr prog =
+
+      let d = Syntax.programDialect prog
+          modDecl = Syntax.programModule prog
+          imports = Syntax.programImports prog
+          exports = Syntax.programExports prog
+          forms = Syntax.programForms prog
+          formPart = Lists.map (topLevelFormWithCommentsToExpr d) forms
+          warning = [
+                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
+        Syntax.DialectClojure -> Optionals.cases modDecl (Serialization.doubleNewlineSep (Lists.concat2 warning formPart)) (\m ->
+          let nameStr = Syntax.unNamespaceName (Syntax.moduleDeclarationName m)
+              requireClauses =
+                      Lists.map (\imp -> Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep [
+                        Serialization.cst imp,
+                        (Serialization.cst ":refer"),
+                        (Serialization.cst ":all")])) importNames
+              nsForm =
+                      Logic.ifElse (Lists.null requireClauses) (Serialization.parens (Serialization.spaceSepAdaptive [
+                        Serialization.cst "ns",
+                        (Serialization.cst nameStr)])) (Serialization.parens (Serialization.newlineSep [
+                        Serialization.spaceSep [
+                          Serialization.cst "ns",
+                          (Serialization.cst nameStr)],
+                        (Serialization.spaceSep (Lists.concat2 [
+                          Serialization.cst "  (:require"] requireClauses)),
+                        (Serialization.cst ")")]))
+              varNames =
+                      Lists.concat (Lists.map (\fwc ->
+                        let form = Syntax.topLevelFormWithCommentsForm fwc
+                        in case form of
+                          Syntax.TopLevelFormVariable v1 -> [
+                            symbolToExpr (Syntax.variableDefinitionName v1)]
+                          Syntax.TopLevelFormFunction v1 -> [
+                            symbolToExpr (Syntax.functionDefinitionName v1)]
+                          _ -> []) forms)
+              declareForm =
+                      Logic.ifElse (Lists.null varNames) [] [
+                        Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+                          Serialization.cst "declare"] varNames))]
+          in (Serialization.doubleNewlineSep (Lists.concat [
+            warning,
+            [
+              nsForm],
+            declareForm,
+            formPart])))
+        Syntax.DialectEmacsLisp -> Optionals.cases modDecl (Serialization.doubleNewlineSep (Lists.concat2 warning formPart)) (\m ->
+          let nameStr = Syntax.unNamespaceName (Syntax.moduleDeclarationName m)
+              requireClLib =
+                      Serialization.parens (Serialization.spaceSepAdaptive [
+                        Serialization.cst "require",
+                        (Serialization.noSep [
+                          Serialization.cst "'",
+                          (Serialization.cst "cl-lib")])])
+              requireImports =
+                      Lists.map (\imp -> Serialization.parens (Serialization.spaceSepAdaptive [
+                        Serialization.cst "require",
+                        (Serialization.noSep [
+                          Serialization.cst "'",
+                          (Serialization.cst imp)])])) importNames
+              provideForm =
+                      Serialization.parens (Serialization.spaceSepAdaptive [
+                        Serialization.cst "provide",
+                        (Serialization.noSep [
+                          Serialization.cst "'",
+                          (Serialization.cst nameStr)])])
+          in (Serialization.doubleNewlineSep (Lists.concat [
+            warning,
+            [
+              requireClLib],
+            requireImports,
+            formPart,
+            [
+              provideForm]])))
+        Syntax.DialectCommonLisp -> Optionals.cases modDecl (Serialization.doubleNewlineSep (Lists.concat2 warning formPart)) (\m ->
+          let nameStr = Syntax.unNamespaceName (Syntax.moduleDeclarationName m)
+              colonName = Strings.cat2 ":" nameStr
+              useClause =
+                      Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+                        Serialization.cst ":use",
+                        (Serialization.cst ":cl")] (Lists.map (\imp -> Serialization.cst (Strings.cat2 ":" imp)) importNames)))
+              exportClause =
+                      Logic.ifElse (Lists.null exportSyms) [] [
+                        Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+                          Serialization.cst ":export"] (Lists.map (\s -> Serialization.noSep [
+                          Serialization.cst ":",
+                          s]) exportSyms)))]
+              defpkgForm =
+                      Serialization.parens (Serialization.newlineSep (Lists.concat [
+                        [
+                          Serialization.spaceSep [
+                            Serialization.cst "defpackage",
+                            (Serialization.cst colonName)]],
+                        [
+                          useClause],
+                        exportClause]))
+              inpkgForm =
+                      Serialization.parens (Serialization.spaceSepAdaptive [
+                        Serialization.cst "in-package",
+                        (Serialization.cst colonName)])
+          in (Serialization.doubleNewlineSep (Lists.concat [
+            warning,
+            [
+              defpkgForm,
+              inpkgForm],
+            formPart])))
+        Syntax.DialectScheme -> Optionals.cases modDecl (Serialization.doubleNewlineSep (Lists.concat2 warning formPart)) (\m ->
+          let nameStr = Syntax.unNamespaceName (Syntax.moduleDeclarationName m)
+              nameParts = Lists.map (\p -> Formatting.convertCaseCamelToLowerSnake p) (Strings.splitOn "." nameStr)
+              nameExpr = Serialization.parens (Serialization.spaceSepAdaptive (Lists.map (\p -> Serialization.cst p) nameParts))
+              domainImportExprs =
+                      Lists.map (\idecl ->
+                        let nsName = Syntax.unNamespaceName (Syntax.importDeclarationModule idecl)
+                            nsParts = Lists.map (\p -> Formatting.convertCaseCamelToLowerSnake p) (Strings.splitOn "." nsName)
+                        in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.map (\p -> Serialization.cst p) nsParts)))) imports
+              schemeBaseExpr =
+                      Serialization.parens (Serialization.spaceSepAdaptive [
+                        Serialization.cst "scheme",
+                        (Serialization.cst "base")])
+              allImportExprs = Lists.concat2 [
+                    schemeBaseExpr] domainImportExprs
+              importClause =
+                      Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+                        Serialization.cst "import"] allImportExprs))
+              exportClauses = Lists.map (\edecl -> exportDeclarationToExpr d edecl) exports
+              beginClause = Serialization.parens (Serialization.newlineSep (Lists.concat2 [
+                    Serialization.cst "begin"] formPart))
+              libraryExpr =
+                      Serialization.parens (Serialization.newlineSep (Lists.concat [
+                        [
+                          Serialization.spaceSep [
+                            Serialization.cst "define-library",
+                            nameExpr]],
+                        exportClauses,
+                        [
+                          importClause],
+                        [
+                          beginClause]]))
+          in (Serialization.doubleNewlineSep (Lists.concat2 warning [
+            libraryExpr])))
+
+recordTypeDefinitionToExpr :: Syntax.Dialect -> Syntax.RecordTypeDefinition -> Ast.Expr
+recordTypeDefinitionToExpr d rdef =
+
+      let name = symbolToExpr (Syntax.recordTypeDefinitionName rdef)
+          fields = Lists.map (\f -> symbolToExpr (Syntax.fieldDefinitionName f)) (Syntax.recordTypeDefinitionFields rdef)
+      in case d of
+        Syntax.DialectClojure ->
+          let nameStr = Syntax.unSymbol (Syntax.recordTypeDefinitionName rdef)
+              fieldNames = Lists.map (\f -> Syntax.unSymbol (Syntax.fieldDefinitionName f)) (Syntax.recordTypeDefinitionFields rdef)
+              defrecordForm =
+                      Serialization.parens (Serialization.spaceSepAdaptive [
+                        Serialization.cst "defrecord",
+                        name,
+                        (Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep fields))])
+              makeAlias =
+                      Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+                        [
+                          Serialization.cst "defn",
+                          (Serialization.cst (Strings.cat2 "make-" nameStr))],
+                        [
+                          Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep fields)],
+                        [
+                          Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+                            Serialization.cst (Strings.cat2 "->" nameStr)] (Lists.map (\fn -> Serialization.cst fn) fieldNames)))]]))
+          in (Serialization.newlineSep [
+            defrecordForm,
+            makeAlias])
+        Syntax.DialectEmacsLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "cl-defstruct",
+            name],
+          fields]))
+        Syntax.DialectCommonLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+          [
+            Serialization.cst "cl:defstruct",
+            name],
+          fields]))
+        Syntax.DialectScheme ->
+          let nameStr = Syntax.unSymbol (Syntax.recordTypeDefinitionName rdef)
+              fieldNames = Lists.map (\f -> Syntax.unSymbol (Syntax.fieldDefinitionName f)) (Syntax.recordTypeDefinitionFields rdef)
+              constructor =
+                      Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+                        Serialization.cst (Strings.cat2 "make-" nameStr)] (Lists.map (\fn -> Serialization.cst fn) fieldNames)))
+              predicate = Serialization.cst (Strings.cat2 nameStr "?")
+              accessors =
+                      Lists.map (\fn -> Serialization.parens (Serialization.spaceSepAdaptive [
+                        Serialization.cst fn,
+                        (Serialization.cst (Strings.cat [
+                          nameStr,
+                          "-",
+                          fn]))])) fieldNames
+          in (Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat [
+            [
+              Serialization.cst "define-record-type",
+              name,
+              constructor,
+              predicate],
+            accessors])))
+
+sExpressionToExpr :: Syntax.SExpression -> Ast.Expr
+sExpressionToExpr sexpr =
+    case sexpr of
+      Syntax.SExpressionAtom v0 -> Serialization.cst v0
+      Syntax.SExpressionList v0 -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.map sExpressionToExpr v0))
+
+setLiteralToExpr :: Syntax.Dialect -> Syntax.SetLiteral -> Ast.Expr
+setLiteralToExpr d sl =
+
+      let elems = Lists.map (expressionToExpr d) (Syntax.setLiteralElements sl)
+      in case d of
+        Syntax.DialectClojure -> Serialization.noSep [
+          Serialization.cst "#",
+          (Serialization.brackets Serialization.curlyBraces Serialization.inlineStyle (Serialization.spaceSep elems))]
+        Syntax.DialectEmacsLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+          Serialization.cst "list"] elems))
+        Syntax.DialectCommonLisp -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+          Serialization.cst "cl:list"] elems))
+        Syntax.DialectScheme -> Serialization.parens (Serialization.spaceSepAdaptive (Lists.concat2 [
+          Serialization.cst "list"] elems))
+
+symbolToExpr :: Syntax.Symbol -> Ast.Expr
+symbolToExpr s = Serialization.cst (Syntax.unSymbol s)
+
+topLevelFormToExpr :: Syntax.Dialect -> Syntax.TopLevelForm -> Ast.Expr
+topLevelFormToExpr d form =
+    case form of
+      Syntax.TopLevelFormFunction v0 -> functionDefinitionToExpr d v0
+      Syntax.TopLevelFormVariable v0 -> variableDefinitionToExpr d v0
+      Syntax.TopLevelFormConstant v0 -> constantDefinitionToExpr d v0
+      Syntax.TopLevelFormRecordType v0 -> recordTypeDefinitionToExpr d v0
+      Syntax.TopLevelFormMacro v0 -> macroDefinitionToExpr d v0
+      Syntax.TopLevelFormExpression v0 -> expressionToExpr d v0
+
+topLevelFormWithCommentsToExpr :: Syntax.Dialect -> Syntax.TopLevelFormWithComments -> Ast.Expr
+topLevelFormWithCommentsToExpr d fwc =
+
+      let mdoc = Syntax.topLevelFormWithCommentsDoc fwc
+          mcomment = Syntax.topLevelFormWithCommentsComment fwc
+          form = Syntax.topLevelFormWithCommentsForm fwc
+          docPart = Optionals.cases mdoc [] (\ds -> [
+                docstringToExpr ds])
+          commentPart = Optionals.cases mcomment [] (\c -> [
+                commentToExpr c])
+          formExpr = topLevelFormToExpr d form
+      in (Serialization.newlineSep (Lists.concat [
+        commentPart,
+        docPart,
+        [
+          formExpr]]))
+
+trueExpr :: Syntax.Dialect -> Ast.Expr
+trueExpr d =
+    case d of
+      Syntax.DialectClojure -> Serialization.cst "true"
+      Syntax.DialectEmacsLisp -> Serialization.cst "t"
+      Syntax.DialectCommonLisp -> Serialization.cst "cl:t"
+      Syntax.DialectScheme -> Serialization.cst "#t"
+
+variableDefinitionToExpr :: Syntax.Dialect -> Syntax.VariableDefinition -> Ast.Expr
+variableDefinitionToExpr d vdef =
+
+      let name = symbolToExpr (Syntax.variableDefinitionName vdef)
+          value = expressionToExpr d (Syntax.variableDefinitionValue vdef)
+      in (Serialization.parens (Serialization.spaceSepAdaptive [
+        Serialization.cst (defKeyword d),
+        name,
+        value]))
+
+variableReferenceToExpr :: Syntax.Dialect -> Syntax.VariableReference -> Ast.Expr
+variableReferenceToExpr d vref =
+
+      let name = symbolToExpr (Syntax.variableReferenceName vref)
+          isFnNs = Syntax.variableReferenceFunctionNamespace vref
+      in (Logic.ifElse isFnNs (case d of
+        Syntax.DialectCommonLisp -> Serialization.noSep [
+          Serialization.cst "#'",
+          name]
+        Syntax.DialectClojure -> name
+        Syntax.DialectEmacsLisp -> name
+        Syntax.DialectScheme -> name) name)
+
+vectorLiteralToExpr :: Syntax.Dialect -> Syntax.VectorLiteral -> Ast.Expr
+vectorLiteralToExpr d vl =
+
+      let elems = Lists.map (expressionToExpr d) (Syntax.vectorLiteralElements vl)
+      in case d of
+        Syntax.DialectClojure -> Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep elems)
+        Syntax.DialectEmacsLisp -> Serialization.brackets Serialization.squareBrackets Serialization.inlineStyle (Serialization.spaceSep elems)
+        Syntax.DialectCommonLisp -> Serialization.noSep [
+          Serialization.cst "#",
+          (Serialization.parens (Serialization.spaceSepAdaptive elems))]
+        Syntax.DialectScheme -> Serialization.noSep [
+          Serialization.cst "#",
+          (Serialization.parens (Serialization.spaceSepAdaptive elems))]
diff --git a/src/main/haskell/Hydra/Lisp/Syntax.hs b/src/main/haskell/Hydra/Lisp/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Lisp/Syntax.hs
@@ -0,0 +1,1176 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | A unified Lisp syntax model covering Clojure, Emacs Lisp, Common Lisp, and Scheme (R7RS). Designed for code generation from Hydra types and terms.
+
+module Hydra.Lisp.Syntax where
+
+import qualified Hydra.Core as Core
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+-- | A Lisp program, consisting of a sequence of top-level forms
+data Program =
+  Program {
+    -- | The target Lisp dialect
+    programDialect :: Dialect,
+    -- | Optional module/namespace declaration
+    programModule :: (Maybe ModuleDeclaration),
+    -- | Import/require declarations
+    programImports :: [ImportDeclaration],
+    -- | Export/provide declarations
+    programExports :: [ExportDeclaration],
+    -- | The top-level forms in the program
+    programForms :: [TopLevelFormWithComments]}
+  deriving (Eq, Ord, Read, Show)
+
+_Program = Core.Name "hydra.lisp.syntax.Program"
+
+_Program_dialect = Core.Name "dialect"
+
+_Program_module = Core.Name "module"
+
+_Program_imports = Core.Name "imports"
+
+_Program_exports = Core.Name "exports"
+
+_Program_forms = Core.Name "forms"
+
+-- | A top-level form in a Lisp program
+data TopLevelForm =
+  -- | A named function definition
+  TopLevelFormFunction FunctionDefinition |
+  -- | A global variable definition
+  TopLevelFormVariable VariableDefinition |
+  -- | A constant definition
+  TopLevelFormConstant ConstantDefinition |
+  -- | A record/struct type definition
+  TopLevelFormRecordType RecordTypeDefinition |
+  -- | A macro definition
+  TopLevelFormMacro MacroDefinition |
+  -- | A bare expression at the top level
+  TopLevelFormExpression Expression
+  deriving (Eq, Ord, Read, Show)
+
+_TopLevelForm = Core.Name "hydra.lisp.syntax.TopLevelForm"
+
+_TopLevelForm_function = Core.Name "function"
+
+_TopLevelForm_variable = Core.Name "variable"
+
+_TopLevelForm_constant = Core.Name "constant"
+
+_TopLevelForm_recordType = Core.Name "recordType"
+
+_TopLevelForm_macro = Core.Name "macro"
+
+_TopLevelForm_expression = Core.Name "expression"
+
+-- | A top-level form together with optional documentation
+data TopLevelFormWithComments =
+  TopLevelFormWithComments {
+    -- | Optional documentation string
+    topLevelFormWithCommentsDoc :: (Maybe Docstring),
+    -- | Optional comment
+    topLevelFormWithCommentsComment :: (Maybe Comment),
+    -- | The form itself
+    topLevelFormWithCommentsForm :: TopLevelForm}
+  deriving (Eq, Ord, Read, Show)
+
+_TopLevelFormWithComments = Core.Name "hydra.lisp.syntax.TopLevelFormWithComments"
+
+_TopLevelFormWithComments_doc = Core.Name "doc"
+
+_TopLevelFormWithComments_comment = Core.Name "comment"
+
+_TopLevelFormWithComments_form = Core.Name "form"
+
+-- | A named function definition. Serializes as (defn name [params] body) in Clojure, (defun name (params) body) in Emacs Lisp and Common Lisp, (define (name params) body) in Scheme
+data FunctionDefinition =
+  FunctionDefinition {
+    -- | The function name
+    functionDefinitionName :: Symbol,
+    -- | The parameter list
+    functionDefinitionParams :: [Symbol],
+    -- | Optional rest/variadic parameter
+    functionDefinitionRestParam :: (Maybe Symbol),
+    -- | Optional docstring
+    functionDefinitionDoc :: (Maybe Docstring),
+    -- | Optional type hints for parameters and return type
+    functionDefinitionTypeHints :: [TypeHint],
+    -- | The function body (one or more expressions)
+    functionDefinitionBody :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_FunctionDefinition = Core.Name "hydra.lisp.syntax.FunctionDefinition"
+
+_FunctionDefinition_name = Core.Name "name"
+
+_FunctionDefinition_params = Core.Name "params"
+
+_FunctionDefinition_restParam = Core.Name "restParam"
+
+_FunctionDefinition_doc = Core.Name "doc"
+
+_FunctionDefinition_typeHints = Core.Name "typeHints"
+
+_FunctionDefinition_body = Core.Name "body"
+
+-- | A global variable definition. Serializes as (def name value) in Clojure, (defvar name value) in Emacs Lisp and Common Lisp, (define name value) in Scheme
+data VariableDefinition =
+  VariableDefinition {
+    -- | The variable name
+    variableDefinitionName :: Symbol,
+    -- | The initial value
+    variableDefinitionValue :: Expression,
+    -- | Optional docstring
+    variableDefinitionDoc :: (Maybe Docstring)}
+  deriving (Eq, Ord, Read, Show)
+
+_VariableDefinition = Core.Name "hydra.lisp.syntax.VariableDefinition"
+
+_VariableDefinition_name = Core.Name "name"
+
+_VariableDefinition_value = Core.Name "value"
+
+_VariableDefinition_doc = Core.Name "doc"
+
+-- | A constant definition. Serializes as (def ^:const name value) in Clojure, (defconst name value) in Emacs Lisp, (defconstant name value) in Common Lisp. Scheme has no dedicated constant form; uses define.
+data ConstantDefinition =
+  ConstantDefinition {
+    -- | The constant name
+    constantDefinitionName :: Symbol,
+    -- | The constant value
+    constantDefinitionValue :: Expression,
+    -- | Optional docstring
+    constantDefinitionDoc :: (Maybe Docstring)}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstantDefinition = Core.Name "hydra.lisp.syntax.ConstantDefinition"
+
+_ConstantDefinition_name = Core.Name "name"
+
+_ConstantDefinition_value = Core.Name "value"
+
+_ConstantDefinition_doc = Core.Name "doc"
+
+-- | A record/struct type definition. Serializes as (defrecord Name [fields]) in Clojure, (cl-defstruct name fields) in Emacs Lisp, (defstruct name fields) in Common Lisp, (define-record-type <Name> ...) in Scheme
+data RecordTypeDefinition =
+  RecordTypeDefinition {
+    -- | The record type name
+    recordTypeDefinitionName :: Symbol,
+    -- | The field definitions
+    recordTypeDefinitionFields :: [FieldDefinition],
+    -- | Optional docstring
+    recordTypeDefinitionDoc :: (Maybe Docstring)}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordTypeDefinition = Core.Name "hydra.lisp.syntax.RecordTypeDefinition"
+
+_RecordTypeDefinition_name = Core.Name "name"
+
+_RecordTypeDefinition_fields = Core.Name "fields"
+
+_RecordTypeDefinition_doc = Core.Name "doc"
+
+-- | A field in a record type definition
+data FieldDefinition =
+  FieldDefinition {
+    -- | The field name
+    fieldDefinitionName :: Symbol,
+    -- | Optional default value
+    fieldDefinitionDefaultValue :: (Maybe Expression)}
+  deriving (Eq, Ord, Read, Show)
+
+_FieldDefinition = Core.Name "hydra.lisp.syntax.FieldDefinition"
+
+_FieldDefinition_name = Core.Name "name"
+
+_FieldDefinition_defaultValue = Core.Name "defaultValue"
+
+-- | A macro definition. Serializes as (defmacro name [params] body) in Clojure, (defmacro name (params) body) in Emacs Lisp and Common Lisp, (define-syntax name ...) in Scheme
+data MacroDefinition =
+  MacroDefinition {
+    -- | The macro name
+    macroDefinitionName :: Symbol,
+    -- | The parameter list
+    macroDefinitionParams :: [Symbol],
+    -- | Optional rest parameter
+    macroDefinitionRestParam :: (Maybe Symbol),
+    -- | The macro body
+    macroDefinitionBody :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_MacroDefinition = Core.Name "hydra.lisp.syntax.MacroDefinition"
+
+_MacroDefinition_name = Core.Name "name"
+
+_MacroDefinition_params = Core.Name "params"
+
+_MacroDefinition_restParam = Core.Name "restParam"
+
+_MacroDefinition_body = Core.Name "body"
+
+-- | A Lisp expression
+data Expression =
+  -- | Function application: (f arg1 arg2 ...)
+  ExpressionApplication Application |
+  -- | Anonymous function
+  ExpressionLambda Lambda |
+  -- | Local variable binding
+  ExpressionLet LetExpression |
+  -- | Conditional expression
+  ExpressionIf IfExpression |
+  -- | Multi-branch conditional
+  ExpressionCond CondExpression |
+  -- | Case/match dispatch
+  ExpressionCase CaseExpression |
+  -- | Logical and (short-circuiting)
+  ExpressionAnd AndExpression |
+  -- | Logical or (short-circuiting)
+  ExpressionOr OrExpression |
+  -- | Logical negation
+  ExpressionNot NotExpression |
+  -- | Sequential evaluation (progn/do/begin)
+  ExpressionDo DoExpression |
+  -- | Sequential evaluation (explicit begin block)
+  ExpressionBegin BeginExpression |
+  -- | Variable reference
+  ExpressionVariable VariableReference |
+  -- | A literal value
+  ExpressionLiteral Literal |
+  -- | A list literal
+  ExpressionList ListLiteral |
+  -- | A vector literal
+  ExpressionVector VectorLiteral |
+  -- | A map/association literal
+  ExpressionMap MapLiteral |
+  -- | A set literal
+  ExpressionSet SetLiteral |
+  -- | A cons expression
+  ExpressionCons ConsExpression |
+  -- | A dotted pair literal
+  ExpressionDottedPair DottedPair |
+  -- | Field access on a record/struct
+  ExpressionFieldAccess FieldAccess |
+  -- | A type-annotated expression
+  ExpressionTypeAnnotation TypeAnnotation |
+  -- | A quoted expression
+  ExpressionQuote QuoteExpression |
+  -- | A quasiquoted expression
+  ExpressionQuasiquote QuasiquoteExpression |
+  -- | An unquoted expression within a quasiquote
+  ExpressionUnquote UnquoteExpression |
+  -- | A splicing unquote within a quasiquote
+  ExpressionSplicingUnquote SplicingUnquoteExpression |
+  -- | An arbitrary S-expression (escape hatch for dialect-specific forms)
+  ExpressionSExpression SExpression
+  deriving (Eq, Ord, Read, Show)
+
+_Expression = Core.Name "hydra.lisp.syntax.Expression"
+
+_Expression_application = Core.Name "application"
+
+_Expression_lambda = Core.Name "lambda"
+
+_Expression_let = Core.Name "let"
+
+_Expression_if = Core.Name "if"
+
+_Expression_cond = Core.Name "cond"
+
+_Expression_case = Core.Name "case"
+
+_Expression_and = Core.Name "and"
+
+_Expression_or = Core.Name "or"
+
+_Expression_not = Core.Name "not"
+
+_Expression_do = Core.Name "do"
+
+_Expression_begin = Core.Name "begin"
+
+_Expression_variable = Core.Name "variable"
+
+_Expression_literal = Core.Name "literal"
+
+_Expression_list = Core.Name "list"
+
+_Expression_vector = Core.Name "vector"
+
+_Expression_map = Core.Name "map"
+
+_Expression_set = Core.Name "set"
+
+_Expression_cons = Core.Name "cons"
+
+_Expression_dottedPair = Core.Name "dottedPair"
+
+_Expression_fieldAccess = Core.Name "fieldAccess"
+
+_Expression_typeAnnotation = Core.Name "typeAnnotation"
+
+_Expression_quote = Core.Name "quote"
+
+_Expression_quasiquote = Core.Name "quasiquote"
+
+_Expression_unquote = Core.Name "unquote"
+
+_Expression_splicingUnquote = Core.Name "splicingUnquote"
+
+_Expression_sExpression = Core.Name "sExpression"
+
+-- | Function application: (function arg1 arg2 ...)
+data Application =
+  Application {
+    -- | The function being applied
+    applicationFunction :: Expression,
+    -- | The arguments
+    applicationArguments :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_Application = Core.Name "hydra.lisp.syntax.Application"
+
+_Application_function = Core.Name "function"
+
+_Application_arguments = Core.Name "arguments"
+
+-- | An anonymous function. Serializes as (fn [params] body) in Clojure, (lambda (params) body) in Emacs Lisp, Common Lisp, and Scheme. If name is provided, emits (fn name [params] body) in Clojure for self-reference.
+data Lambda =
+  Lambda {
+    -- | Optional name for self-referential lambdas (Clojure named fn)
+    lambdaName :: (Maybe Symbol),
+    -- | The parameter list
+    lambdaParams :: [Symbol],
+    -- | Optional rest parameter
+    lambdaRestParam :: (Maybe Symbol),
+    -- | The lambda body
+    lambdaBody :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_Lambda = Core.Name "hydra.lisp.syntax.Lambda"
+
+_Lambda_name = Core.Name "name"
+
+_Lambda_params = Core.Name "params"
+
+_Lambda_restParam = Core.Name "restParam"
+
+_Lambda_body = Core.Name "body"
+
+-- | A reference to a variable by name
+data VariableReference =
+  VariableReference {
+    -- | The variable name
+    variableReferenceName :: Symbol,
+    -- | Whether to reference from the function namespace. In Lisp-2 dialects (Common Lisp), this emits #'name. In Lisp-1 dialects, this has no effect.
+    variableReferenceFunctionNamespace :: Bool}
+  deriving (Eq, Ord, Read, Show)
+
+_VariableReference = Core.Name "hydra.lisp.syntax.VariableReference"
+
+_VariableReference_name = Core.Name "name"
+
+_VariableReference_functionNamespace = Core.Name "functionNamespace"
+
+-- | Field access on a record/struct. Serializes as (:field record) in Clojure, (struct-field record) in Emacs Lisp and Common Lisp, (record-field record) in Scheme
+data FieldAccess =
+  FieldAccess {
+    -- | The record type name (used to form accessor name)
+    fieldAccessRecordType :: Symbol,
+    -- | The field name
+    fieldAccessField :: Symbol,
+    -- | The expression being accessed
+    fieldAccessTarget :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_FieldAccess = Core.Name "hydra.lisp.syntax.FieldAccess"
+
+_FieldAccess_recordType = Core.Name "recordType"
+
+_FieldAccess_field = Core.Name "field"
+
+_FieldAccess_target = Core.Name "target"
+
+-- | An expression with a type annotation
+data TypeAnnotation =
+  TypeAnnotation {
+    -- | The annotated expression
+    typeAnnotationExpression :: Expression,
+    -- | The type specifier
+    typeAnnotationType :: TypeSpecifier}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeAnnotation = Core.Name "hydra.lisp.syntax.TypeAnnotation"
+
+_TypeAnnotation_expression = Core.Name "expression"
+
+_TypeAnnotation_type = Core.Name "type"
+
+-- | Conditional: (if test then else)
+data IfExpression =
+  IfExpression {
+    -- | The test expression
+    ifExpressionCondition :: Expression,
+    -- | The then branch
+    ifExpressionThen :: Expression,
+    -- | Optional else branch
+    ifExpressionElse :: (Maybe Expression)}
+  deriving (Eq, Ord, Read, Show)
+
+_IfExpression = Core.Name "hydra.lisp.syntax.IfExpression"
+
+_IfExpression_condition = Core.Name "condition"
+
+_IfExpression_then = Core.Name "then"
+
+_IfExpression_else = Core.Name "else"
+
+-- | Multi-branch conditional. Serializes as (cond test1 expr1 test2 expr2 :else default) in Clojure, (cond (test1 expr1) (test2 expr2) (t default)) in Emacs Lisp and Common Lisp, (cond (test1 expr1) (test2 expr2) (else default)) in Scheme
+data CondExpression =
+  CondExpression {
+    -- | The condition-expression pairs
+    condExpressionClauses :: [CondClause],
+    -- | Optional default expression
+    condExpressionDefault :: (Maybe Expression)}
+  deriving (Eq, Ord, Read, Show)
+
+_CondExpression = Core.Name "hydra.lisp.syntax.CondExpression"
+
+_CondExpression_clauses = Core.Name "clauses"
+
+_CondExpression_default = Core.Name "default"
+
+-- | A clause in a cond expression
+data CondClause =
+  CondClause {
+    -- | The test condition
+    condClauseCondition :: Expression,
+    -- | The result expression
+    condClauseBody :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_CondClause = Core.Name "hydra.lisp.syntax.CondClause"
+
+_CondClause_condition = Core.Name "condition"
+
+_CondClause_body = Core.Name "body"
+
+-- | Case dispatch on a value. Serializes as (case x key1 expr1 key2 expr2 default) in Clojure, (case x (key1 expr1) (key2 expr2) (otherwise default)) in Common Lisp, (case x ((key1) expr1) ((key2) expr2) (else default)) in Scheme
+data CaseExpression =
+  CaseExpression {
+    -- | The expression being dispatched on
+    caseExpressionScrutinee :: Expression,
+    -- | The case clauses
+    caseExpressionClauses :: [CaseClause],
+    -- | Optional default clause
+    caseExpressionDefault :: (Maybe Expression)}
+  deriving (Eq, Ord, Read, Show)
+
+_CaseExpression = Core.Name "hydra.lisp.syntax.CaseExpression"
+
+_CaseExpression_scrutinee = Core.Name "scrutinee"
+
+_CaseExpression_clauses = Core.Name "clauses"
+
+_CaseExpression_default = Core.Name "default"
+
+-- | A clause in a case expression
+data CaseClause =
+  CaseClause {
+    -- | The matching keys (one or more datum values)
+    caseClauseKeys :: [Expression],
+    -- | The result expression
+    caseClauseBody :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_CaseClause = Core.Name "hydra.lisp.syntax.CaseClause"
+
+_CaseClause_keys = Core.Name "keys"
+
+_CaseClause_body = Core.Name "body"
+
+-- | Logical and: (and expr1 expr2 ...)
+data AndExpression =
+  AndExpression {
+    -- | The operand expressions
+    andExpressionExpressions :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_AndExpression = Core.Name "hydra.lisp.syntax.AndExpression"
+
+_AndExpression_expressions = Core.Name "expressions"
+
+-- | Logical or: (or expr1 expr2 ...)
+data OrExpression =
+  OrExpression {
+    -- | The operand expressions
+    orExpressionExpressions :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_OrExpression = Core.Name "hydra.lisp.syntax.OrExpression"
+
+_OrExpression_expressions = Core.Name "expressions"
+
+-- | Logical negation: (not expr)
+data NotExpression =
+  NotExpression {
+    -- | The operand expression
+    notExpressionExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_NotExpression = Core.Name "hydra.lisp.syntax.NotExpression"
+
+_NotExpression_expression = Core.Name "expression"
+
+-- | Sequential evaluation of expressions, returning the last. Serializes as (do expr1 expr2 ...) in Clojure, (progn expr1 expr2 ...) in Emacs Lisp and Common Lisp, (begin expr1 expr2 ...) in Scheme
+data DoExpression =
+  DoExpression {
+    -- | The expressions to evaluate in sequence
+    doExpressionExpressions :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_DoExpression = Core.Name "hydra.lisp.syntax.DoExpression"
+
+_DoExpression_expressions = Core.Name "expressions"
+
+-- | An explicit begin block (distinct from do for Scheme compatibility)
+data BeginExpression =
+  BeginExpression {
+    -- | The expressions to evaluate in sequence
+    beginExpressionExpressions :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_BeginExpression = Core.Name "hydra.lisp.syntax.BeginExpression"
+
+_BeginExpression_expressions = Core.Name "expressions"
+
+-- | A quoted form: 'expr or (quote expr)
+data QuoteExpression =
+  QuoteExpression {
+    -- | The quoted form
+    quoteExpressionBody :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_QuoteExpression = Core.Name "hydra.lisp.syntax.QuoteExpression"
+
+_QuoteExpression_body = Core.Name "body"
+
+-- | A quasiquoted form: `expr
+data QuasiquoteExpression =
+  QuasiquoteExpression {
+    -- | The quasiquoted form
+    quasiquoteExpressionBody :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_QuasiquoteExpression = Core.Name "hydra.lisp.syntax.QuasiquoteExpression"
+
+_QuasiquoteExpression_body = Core.Name "body"
+
+-- | An unquoted form within a quasiquote: ~expr or ,expr
+data UnquoteExpression =
+  UnquoteExpression {
+    -- | The unquoted form
+    unquoteExpressionBody :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_UnquoteExpression = Core.Name "hydra.lisp.syntax.UnquoteExpression"
+
+_UnquoteExpression_body = Core.Name "body"
+
+-- | A splicing unquote within a quasiquote: ~@expr or ,@expr
+data SplicingUnquoteExpression =
+  SplicingUnquoteExpression {
+    -- | The spliced form
+    splicingUnquoteExpressionBody :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_SplicingUnquoteExpression = Core.Name "hydra.lisp.syntax.SplicingUnquoteExpression"
+
+_SplicingUnquoteExpression_body = Core.Name "body"
+
+-- | Local variable bindings. Serializes as (let [x 1 y 2] body) in Clojure (always sequential), (let ((x 1) (y 2)) body) or (let* ...) in other dialects
+data LetExpression =
+  LetExpression {
+    -- | The kind of let (parallel or sequential)
+    letExpressionKind :: LetKind,
+    -- | The variable bindings
+    letExpressionBindings :: [LetBinding],
+    -- | The body expressions
+    letExpressionBody :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_LetExpression = Core.Name "hydra.lisp.syntax.LetExpression"
+
+_LetExpression_kind = Core.Name "kind"
+
+_LetExpression_bindings = Core.Name "bindings"
+
+_LetExpression_body = Core.Name "body"
+
+-- | The kind of let binding
+data LetKind =
+  LetKindParallel |
+  LetKindSequential |
+  LetKindRecursive
+  deriving (Eq, Ord, Read, Show)
+
+_LetKind = Core.Name "hydra.lisp.syntax.LetKind"
+
+_LetKind_parallel = Core.Name "parallel"
+
+_LetKind_sequential = Core.Name "sequential"
+
+_LetKind_recursive = Core.Name "recursive"
+
+-- | A single binding in a let expression
+data LetBinding =
+  -- | A simple name-value binding
+  LetBindingSimple SimpleBinding |
+  -- | A destructuring binding
+  LetBindingDestructuring DestructuringBinding
+  deriving (Eq, Ord, Read, Show)
+
+_LetBinding = Core.Name "hydra.lisp.syntax.LetBinding"
+
+_LetBinding_simple = Core.Name "simple"
+
+_LetBinding_destructuring = Core.Name "destructuring"
+
+-- | A simple name-value binding in a let expression
+data SimpleBinding =
+  SimpleBinding {
+    -- | The bound variable
+    simpleBindingName :: Symbol,
+    -- | The value expression
+    simpleBindingValue :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_SimpleBinding = Core.Name "hydra.lisp.syntax.SimpleBinding"
+
+_SimpleBinding_name = Core.Name "name"
+
+_SimpleBinding_value = Core.Name "value"
+
+-- | A destructuring binding in a let expression
+data DestructuringBinding =
+  DestructuringBinding {
+    -- | The destructuring pattern
+    destructuringBindingPattern :: DestructuringPattern,
+    -- | The value to destructure
+    destructuringBindingValue :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_DestructuringBinding = Core.Name "hydra.lisp.syntax.DestructuringBinding"
+
+_DestructuringBinding_pattern = Core.Name "pattern"
+
+_DestructuringBinding_value = Core.Name "value"
+
+-- | A destructuring pattern
+data DestructuringPattern =
+  -- | Sequential destructuring: [a b c] in Clojure, (a b c) in others
+  DestructuringPatternSequential [Symbol] |
+  -- | Associative/map destructuring: {:keys [a b]} in Clojure
+  DestructuringPatternAssociative [Symbol] |
+  -- | Destructuring with a rest element: [a b & rest] (leading symbols + rest symbol)
+  DestructuringPatternRest [Symbol]
+  deriving (Eq, Ord, Read, Show)
+
+_DestructuringPattern = Core.Name "hydra.lisp.syntax.DestructuringPattern"
+
+_DestructuringPattern_sequential = Core.Name "sequential"
+
+_DestructuringPattern_associative = Core.Name "associative"
+
+_DestructuringPattern_rest = Core.Name "rest"
+
+-- | A pattern for use in case expressions or match forms
+data Pattern =
+  -- | A constructor pattern (for union/sum type matching)
+  PatternConstructor ConstructorPattern |
+  -- | A literal pattern
+  PatternLiteral LiteralPattern |
+  -- | A wildcard pattern matching anything
+  PatternWildcard WildcardPattern |
+  -- | A variable pattern that binds the matched value
+  PatternVariable Symbol
+  deriving (Eq, Ord, Read, Show)
+
+_Pattern = Core.Name "hydra.lisp.syntax.Pattern"
+
+_Pattern_constructor = Core.Name "constructor"
+
+_Pattern_literal = Core.Name "literal"
+
+_Pattern_wildcard = Core.Name "wildcard"
+
+_Pattern_variable = Core.Name "variable"
+
+-- | A constructor pattern matching a tagged value
+data ConstructorPattern =
+  ConstructorPattern {
+    -- | The constructor/tag name
+    constructorPatternConstructor :: Symbol,
+    -- | The sub-patterns for constructor arguments
+    constructorPatternArguments :: [Pattern]}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstructorPattern = Core.Name "hydra.lisp.syntax.ConstructorPattern"
+
+_ConstructorPattern_constructor = Core.Name "constructor"
+
+_ConstructorPattern_arguments = Core.Name "arguments"
+
+-- | A pattern matching a literal value
+data LiteralPattern =
+  LiteralPattern {
+    -- | The literal to match
+    literalPatternValue :: Literal}
+  deriving (Eq, Ord, Read, Show)
+
+_LiteralPattern = Core.Name "hydra.lisp.syntax.LiteralPattern"
+
+_LiteralPattern_value = Core.Name "value"
+
+-- | A wildcard pattern that matches any value
+data WildcardPattern =
+  WildcardPattern {}
+  deriving (Eq, Ord, Read, Show)
+
+_WildcardPattern = Core.Name "hydra.lisp.syntax.WildcardPattern"
+
+-- | A Lisp literal value
+data Literal =
+  -- | An integer literal
+  LiteralInteger IntegerLiteral |
+  -- | A floating-point literal
+  LiteralFloat FloatLiteral |
+  -- | A string literal
+  LiteralString String |
+  -- | A character literal
+  LiteralCharacter CharacterLiteral |
+  -- | A boolean literal (dialect-specific rendering)
+  LiteralBoolean Bool |
+  -- | Nil/null/empty list (dialect-specific rendering)
+  LiteralNil |
+  -- | A keyword literal
+  LiteralKeyword Keyword |
+  -- | A quoted symbol literal
+  LiteralSymbol Symbol
+  deriving (Eq, Ord, Read, Show)
+
+_Literal = Core.Name "hydra.lisp.syntax.Literal"
+
+_Literal_integer = Core.Name "integer"
+
+_Literal_float = Core.Name "float"
+
+_Literal_string = Core.Name "string"
+
+_Literal_character = Core.Name "character"
+
+_Literal_boolean = Core.Name "boolean"
+
+_Literal_nil = Core.Name "nil"
+
+_Literal_keyword = Core.Name "keyword"
+
+_Literal_symbol = Core.Name "symbol"
+
+-- | An integer literal
+data IntegerLiteral =
+  IntegerLiteral {
+    -- | The integer value
+    integerLiteralValue :: Integer,
+    -- | Whether this is explicitly a big integer (e.g. 42N in Clojure)
+    integerLiteralBigint :: Bool}
+  deriving (Eq, Ord, Read, Show)
+
+_IntegerLiteral = Core.Name "hydra.lisp.syntax.IntegerLiteral"
+
+_IntegerLiteral_value = Core.Name "value"
+
+_IntegerLiteral_bigint = Core.Name "bigint"
+
+-- | A floating-point literal
+data FloatLiteral =
+  FloatLiteral {
+    -- | The float value
+    floatLiteralValue :: Double,
+    -- | Optional precision hint (e.g. 3.14d0 vs 3.14f0 in Common Lisp)
+    floatLiteralPrecision :: (Maybe String)}
+  deriving (Eq, Ord, Read, Show)
+
+_FloatLiteral = Core.Name "hydra.lisp.syntax.FloatLiteral"
+
+_FloatLiteral_value = Core.Name "value"
+
+_FloatLiteral_precision = Core.Name "precision"
+
+-- | A character literal. Concrete syntax varies: \a (Clojure), ?a (Emacs Lisp), #\a (Common Lisp, Scheme)
+data CharacterLiteral =
+  CharacterLiteral {
+    -- | The character value
+    characterLiteralValue :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_CharacterLiteral = Core.Name "hydra.lisp.syntax.CharacterLiteral"
+
+_CharacterLiteral_value = Core.Name "value"
+
+-- | The style of boolean literals in a dialect
+data BooleanStyle =
+  BooleanStyleTrueFalse |
+  BooleanStyleTNil |
+  BooleanStyleHashTF
+  deriving (Eq, Ord, Read, Show)
+
+_BooleanStyle = Core.Name "hydra.lisp.syntax.BooleanStyle"
+
+_BooleanStyle_trueFalse = Core.Name "trueFalse"
+
+_BooleanStyle_tNil = Core.Name "tNil"
+
+_BooleanStyle_hashTF = Core.Name "hashTF"
+
+-- | The style of nil/null in a dialect
+data NilStyle =
+  NilStyleNil |
+  NilStyleEmptyList
+  deriving (Eq, Ord, Read, Show)
+
+_NilStyle = Core.Name "hydra.lisp.syntax.NilStyle"
+
+_NilStyle_nil = Core.Name "nil"
+
+_NilStyle_emptyList = Core.Name "emptyList"
+
+-- | A Lisp symbol (identifier)
+newtype Symbol =
+  Symbol {
+    unSymbol :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_Symbol = Core.Name "hydra.lisp.syntax.Symbol"
+
+-- | A keyword (self-evaluating symbol). Serializes as :name in Clojure, Emacs Lisp, and Common Lisp
+data Keyword =
+  Keyword {
+    -- | The keyword name (without the leading colon)
+    keywordName :: String,
+    -- | Optional namespace (e.g. my.ns/foo in Clojure)
+    keywordNamespace :: (Maybe String)}
+  deriving (Eq, Ord, Read, Show)
+
+_Keyword = Core.Name "hydra.lisp.syntax.Keyword"
+
+_Keyword_name = Core.Name "name"
+
+_Keyword_namespace = Core.Name "namespace"
+
+-- | A namespace-qualified symbol. Serializes as ns/name in Clojure, pkg:name or pkg::name in Common Lisp
+data QualifiedSymbol =
+  QualifiedSymbol {
+    -- | The namespace or package
+    qualifiedSymbolNamespace :: String,
+    -- | The local name
+    qualifiedSymbolName :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_QualifiedSymbol = Core.Name "hydra.lisp.syntax.QualifiedSymbol"
+
+_QualifiedSymbol_namespace = Core.Name "namespace"
+
+_QualifiedSymbol_name = Core.Name "name"
+
+-- | A namespace or package name
+newtype NamespaceName =
+  NamespaceName {
+    unNamespaceName :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_NamespaceName = Core.Name "hydra.lisp.syntax.NamespaceName"
+
+-- | A list literal: '(1 2 3) or (list 1 2 3)
+data ListLiteral =
+  ListLiteral {
+    -- | The list elements
+    listLiteralElements :: [Expression],
+    -- | Whether to use quote syntax vs constructor syntax
+    listLiteralQuoted :: Bool}
+  deriving (Eq, Ord, Read, Show)
+
+_ListLiteral = Core.Name "hydra.lisp.syntax.ListLiteral"
+
+_ListLiteral_elements = Core.Name "elements"
+
+_ListLiteral_quoted = Core.Name "quoted"
+
+-- | A vector literal. Serializes as [1 2 3] in Clojure and Emacs Lisp, #(1 2 3) in Common Lisp and Scheme
+data VectorLiteral =
+  VectorLiteral {
+    -- | The vector elements
+    vectorLiteralElements :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_VectorLiteral = Core.Name "hydra.lisp.syntax.VectorLiteral"
+
+_VectorLiteral_elements = Core.Name "elements"
+
+-- | A map/dictionary literal. Serializes as {:a 1 :b 2} in Clojure, as an alist '((a . 1) (b . 2)) in other dialects
+data MapLiteral =
+  MapLiteral {
+    -- | The key-value pairs
+    mapLiteralEntries :: [MapEntry]}
+  deriving (Eq, Ord, Read, Show)
+
+_MapLiteral = Core.Name "hydra.lisp.syntax.MapLiteral"
+
+_MapLiteral_entries = Core.Name "entries"
+
+-- | A key-value pair in a map literal
+data MapEntry =
+  MapEntry {
+    -- | The key expression
+    mapEntryKey :: Expression,
+    -- | The value expression
+    mapEntryValue :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_MapEntry = Core.Name "hydra.lisp.syntax.MapEntry"
+
+_MapEntry_key = Core.Name "key"
+
+_MapEntry_value = Core.Name "value"
+
+-- | A set literal. Serializes as #{1 2 3} in Clojure. Other dialects use a list-based construction.
+data SetLiteral =
+  SetLiteral {
+    -- | The set elements
+    setLiteralElements :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_SetLiteral = Core.Name "hydra.lisp.syntax.SetLiteral"
+
+_SetLiteral_elements = Core.Name "elements"
+
+-- | A cons expression: (cons head tail)
+data ConsExpression =
+  ConsExpression {
+    -- | The head element
+    consExpressionHead :: Expression,
+    -- | The tail (typically a list or another cons)
+    consExpressionTail :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_ConsExpression = Core.Name "hydra.lisp.syntax.ConsExpression"
+
+_ConsExpression_head = Core.Name "head"
+
+_ConsExpression_tail = Core.Name "tail"
+
+-- | A dotted pair literal: '(a . b). Not available in Clojure.
+data DottedPair =
+  DottedPair {
+    -- | The first element
+    dottedPairCar :: Expression,
+    -- | The second element
+    dottedPairCdr :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_DottedPair = Core.Name "hydra.lisp.syntax.DottedPair"
+
+_DottedPair_car = Core.Name "car"
+
+_DottedPair_cdr = Core.Name "cdr"
+
+-- | A type hint or annotation. In Clojure: ^Type name. In Common Lisp: (declare (type Type name)). In Scheme and Emacs Lisp: typically unused.
+data TypeHint =
+  TypeHint {
+    -- | The annotated symbol
+    typeHintName :: Symbol,
+    -- | The type specifier
+    typeHintType :: TypeSpecifier}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeHint = Core.Name "hydra.lisp.syntax.TypeHint"
+
+_TypeHint_name = Core.Name "name"
+
+_TypeHint_type = Core.Name "type"
+
+-- | A type specifier
+data TypeSpecifier =
+  -- | A named type reference
+  TypeSpecifierNamed Symbol |
+  -- | A list type
+  TypeSpecifierList TypeSpecifier |
+  -- | A function type (params and return)
+  TypeSpecifierFunction [TypeSpecifier] |
+  -- | An optional type
+  TypeSpecifierMaybe TypeSpecifier |
+  -- | A map type (key and value type specifiers)
+  TypeSpecifierMap [TypeSpecifier] |
+  -- | A set type
+  TypeSpecifierSet TypeSpecifier |
+  -- | A pair/tuple type (two type specifiers)
+  TypeSpecifierPair [TypeSpecifier] |
+  -- | An either/union type (two type specifiers)
+  TypeSpecifierEither [TypeSpecifier] |
+  -- | The unit type
+  TypeSpecifierUnit
+  deriving (Eq, Ord, Read, Show)
+
+_TypeSpecifier = Core.Name "hydra.lisp.syntax.TypeSpecifier"
+
+_TypeSpecifier_named = Core.Name "named"
+
+_TypeSpecifier_list = Core.Name "list"
+
+_TypeSpecifier_function = Core.Name "function"
+
+_TypeSpecifier_maybe = Core.Name "maybe"
+
+_TypeSpecifier_map = Core.Name "map"
+
+_TypeSpecifier_set = Core.Name "set"
+
+_TypeSpecifier_pair = Core.Name "pair"
+
+_TypeSpecifier_either = Core.Name "either"
+
+_TypeSpecifier_unit = Core.Name "unit"
+
+-- | A module/namespace declaration. Serializes as (ns name ...) in Clojure, (provide 'name) in Emacs Lisp, (defpackage :name ... ) (in-package :name) in Common Lisp, (define-library (name) ...) in Scheme
+data ModuleDeclaration =
+  ModuleDeclaration {
+    -- | The module/namespace name
+    moduleDeclarationName :: NamespaceName,
+    -- | Optional module documentation
+    moduleDeclarationDoc :: (Maybe Docstring)}
+  deriving (Eq, Ord, Read, Show)
+
+_ModuleDeclaration = Core.Name "hydra.lisp.syntax.ModuleDeclaration"
+
+_ModuleDeclaration_name = Core.Name "name"
+
+_ModuleDeclaration_doc = Core.Name "doc"
+
+-- | An import/require declaration. Serializes as (:require [name ...]) in Clojure, (require 'name) in Emacs Lisp, (:use :name) or (:import-from :name ...) in Common Lisp, (import (name)) in Scheme
+data ImportDeclaration =
+  ImportDeclaration {
+    -- | The module being imported
+    importDeclarationModule :: NamespaceName,
+    -- | Import specification
+    importDeclarationSpec :: ImportSpec}
+  deriving (Eq, Ord, Read, Show)
+
+_ImportDeclaration = Core.Name "hydra.lisp.syntax.ImportDeclaration"
+
+_ImportDeclaration_module = Core.Name "module"
+
+_ImportDeclaration_spec = Core.Name "spec"
+
+-- | An import specification describing how to import symbols
+data ImportSpec =
+  -- | Import everything
+  ImportSpecAll |
+  -- | Import with an alias: (:require [name :as alias]) in Clojure
+  ImportSpecAlias Symbol |
+  -- | Import specific symbols: (:require [name :refer [sym1 sym2]]) in Clojure
+  ImportSpecOnly [Symbol] |
+  -- | Import with renaming: list of (from, to) symbol pairs
+  ImportSpecRename [[Symbol]]
+  deriving (Eq, Ord, Read, Show)
+
+_ImportSpec = Core.Name "hydra.lisp.syntax.ImportSpec"
+
+_ImportSpec_all = Core.Name "all"
+
+_ImportSpec_alias = Core.Name "alias"
+
+_ImportSpec_only = Core.Name "only"
+
+_ImportSpec_rename = Core.Name "rename"
+
+-- | An export/provide declaration. Serializes as (provide 'name) in Emacs Lisp, (:export :sym1 :sym2) in Common Lisp, (export sym1 sym2) in Scheme. In Clojure, symbols are public by default.
+data ExportDeclaration =
+  ExportDeclaration {
+    -- | The symbols to export
+    exportDeclarationSymbols :: [Symbol]}
+  deriving (Eq, Ord, Read, Show)
+
+_ExportDeclaration = Core.Name "hydra.lisp.syntax.ExportDeclaration"
+
+_ExportDeclaration_symbols = Core.Name "symbols"
+
+-- | A comment
+data Comment =
+  Comment {
+    -- | The comment style
+    commentStyle :: CommentStyle,
+    -- | The comment text
+    commentText :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_Comment = Core.Name "hydra.lisp.syntax.Comment"
+
+_Comment_style = Core.Name "style"
+
+_Comment_text = Core.Name "text"
+
+-- | The style of a comment
+data CommentStyle =
+  CommentStyleLine |
+  CommentStyleBlock |
+  CommentStyleDatum
+  deriving (Eq, Ord, Read, Show)
+
+_CommentStyle = Core.Name "hydra.lisp.syntax.CommentStyle"
+
+_CommentStyle_line = Core.Name "line"
+
+_CommentStyle_block = Core.Name "block"
+
+_CommentStyle_datum = Core.Name "datum"
+
+-- | A documentation string
+newtype Docstring =
+  Docstring {
+    unDocstring :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_Docstring = Core.Name "hydra.lisp.syntax.Docstring"
+
+-- | A Lisp dialect
+data Dialect =
+  DialectClojure |
+  DialectEmacsLisp |
+  DialectCommonLisp |
+  DialectScheme
+  deriving (Eq, Ord, Read, Show)
+
+_Dialect = Core.Name "hydra.lisp.syntax.Dialect"
+
+_Dialect_clojure = Core.Name "clojure"
+
+_Dialect_emacsLisp = Core.Name "emacsLisp"
+
+_Dialect_commonLisp = Core.Name "commonLisp"
+
+_Dialect_scheme = Core.Name "scheme"
+
+-- | A raw S-expression. This is an escape hatch for expressing arbitrary Lisp forms that do not fit into the structured AST above.
+data SExpression =
+  -- | An atomic value
+  SExpressionAtom String |
+  -- | A list of S-expressions
+  SExpressionList [SExpression]
+  deriving (Eq, Ord, Read, Show)
+
+_SExpression = Core.Name "hydra.lisp.syntax.SExpression"
+
+_SExpression_atom = Core.Name "atom"
+
+_SExpression_list = Core.Name "list"