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-go.cabal b/hydra-go.cabal
new file mode 100644
--- /dev/null
+++ b/hydra-go.cabal
@@ -0,0 +1,42 @@
+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-go
+version:        0.17.0
+synopsis:       Hydra's Go coder: emit Go source from Hydra modules
+description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". Go support for Hydra
+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.Go.Syntax
+      Hydra.Go.Language
+      Hydra.Go.Syntax
+  other-modules:
+      Paths_hydra_go
+  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/Go/Syntax.hs b/src/main/haskell/Hydra/Dsl/Go/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Dsl/Go/Syntax.hs
@@ -0,0 +1,6562 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | DSL functions for hydra.go.syntax
+
+module Hydra.Dsl.Go.Syntax where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.Dsl.Core as DslCore
+import qualified Hydra.Go.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 injection for the add variant of hydra.go.syntax.AddOp
+addOpAdd :: Typed.TypedTerm Syntax.AddOp
+addOpAdd =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.AddOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "add"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the bitwiseOr variant of hydra.go.syntax.AddOp
+addOpBitwiseOr :: Typed.TypedTerm Syntax.AddOp
+addOpBitwiseOr =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.AddOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bitwiseOr"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the bitwiseXor variant of hydra.go.syntax.AddOp
+addOpBitwiseXor :: Typed.TypedTerm Syntax.AddOp
+addOpBitwiseXor =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.AddOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bitwiseXor"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the subtract variant of hydra.go.syntax.AddOp
+addOpSubtract :: Typed.TypedTerm Syntax.AddOp
+addOpSubtract =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.AddOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "subtract"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.go.syntax.AliasDecl
+aliasDecl :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AliasDecl
+aliasDecl name type_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.AliasDecl"),
+      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.go.syntax.AliasDecl
+aliasDeclName :: Typed.TypedTerm Syntax.AliasDecl -> Typed.TypedTerm Syntax.Identifier
+aliasDeclName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.AliasDecl"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.AliasDecl
+aliasDeclType :: Typed.TypedTerm Syntax.AliasDecl -> Typed.TypedTerm Syntax.Type
+aliasDeclType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.AliasDecl"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.go.syntax.AliasDecl
+aliasDeclWithName :: Typed.TypedTerm Syntax.AliasDecl -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AliasDecl
+aliasDeclWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.AliasDecl"),
+      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.go.syntax.AliasDecl"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.AliasDecl
+aliasDeclWithType :: Typed.TypedTerm Syntax.AliasDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AliasDecl
+aliasDeclWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.AliasDecl"),
+      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.go.syntax.AliasDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.AnnotatedDeclaration
+annotatedDeclaration :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.TopLevelDecl -> Typed.TypedTerm Syntax.AnnotatedDeclaration
+annotatedDeclaration comment declaration =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.AnnotatedDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "comment"),
+          Core.fieldTerm = (Typed.unTypedTerm comment)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declaration"),
+          Core.fieldTerm = (Typed.unTypedTerm declaration)}]}))
+
+-- | DSL accessor for the comment field of hydra.go.syntax.AnnotatedDeclaration
+annotatedDeclarationComment :: Typed.TypedTerm Syntax.AnnotatedDeclaration -> Typed.TypedTerm String
+annotatedDeclarationComment x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.AnnotatedDeclaration"),
+        Core.projectionFieldName = (Core.Name "comment")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the declaration field of hydra.go.syntax.AnnotatedDeclaration
+annotatedDeclarationDeclaration :: Typed.TypedTerm Syntax.AnnotatedDeclaration -> Typed.TypedTerm Syntax.TopLevelDecl
+annotatedDeclarationDeclaration x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.AnnotatedDeclaration"),
+        Core.projectionFieldName = (Core.Name "declaration")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the comment field of hydra.go.syntax.AnnotatedDeclaration
+annotatedDeclarationWithComment :: Typed.TypedTerm Syntax.AnnotatedDeclaration -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.AnnotatedDeclaration
+annotatedDeclarationWithComment original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.AnnotatedDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "comment"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declaration"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.AnnotatedDeclaration"),
+              Core.projectionFieldName = (Core.Name "declaration")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the declaration field of hydra.go.syntax.AnnotatedDeclaration
+annotatedDeclarationWithDeclaration :: Typed.TypedTerm Syntax.AnnotatedDeclaration -> Typed.TypedTerm Syntax.TopLevelDecl -> Typed.TypedTerm Syntax.AnnotatedDeclaration
+annotatedDeclarationWithDeclaration original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.AnnotatedDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "comment"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.AnnotatedDeclaration"),
+              Core.projectionFieldName = (Core.Name "comment")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declaration"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.Arguments
+arguments :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Arguments
+arguments typeArg expressions ellipsis =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArg"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArg)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm expressions)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ellipsis"),
+          Core.fieldTerm = (Typed.unTypedTerm ellipsis)}]}))
+
+-- | DSL accessor for the ellipsis field of hydra.go.syntax.Arguments
+argumentsEllipsis :: Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm Bool
+argumentsEllipsis x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+        Core.projectionFieldName = (Core.Name "ellipsis")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expressions field of hydra.go.syntax.Arguments
+argumentsExpressions :: Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm [Syntax.Expression]
+argumentsExpressions x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+        Core.projectionFieldName = (Core.Name "expressions")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArg field of hydra.go.syntax.Arguments
+argumentsTypeArg :: Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm (Maybe Syntax.Type)
+argumentsTypeArg x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+        Core.projectionFieldName = (Core.Name "typeArg")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the ellipsis field of hydra.go.syntax.Arguments
+argumentsWithEllipsis :: Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Arguments
+argumentsWithEllipsis original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArg"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+              Core.projectionFieldName = (Core.Name "typeArg")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+              Core.projectionFieldName = (Core.Name "expressions")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ellipsis"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the expressions field of hydra.go.syntax.Arguments
+argumentsWithExpressions :: Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Arguments
+argumentsWithExpressions original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArg"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+              Core.projectionFieldName = (Core.Name "typeArg")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ellipsis"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+              Core.projectionFieldName = (Core.Name "ellipsis")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArg field of hydra.go.syntax.Arguments
+argumentsWithTypeArg :: Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Arguments
+argumentsWithTypeArg original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArg"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expressions"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+              Core.projectionFieldName = (Core.Name "expressions")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ellipsis"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Arguments"),
+              Core.projectionFieldName = (Core.Name "ellipsis")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.ArrayType
+arrayType :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ArrayType
+arrayType length element =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ArrayType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "length"),
+          Core.fieldTerm = (Typed.unTypedTerm length)},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Typed.unTypedTerm element)}]}))
+
+-- | DSL accessor for the element field of hydra.go.syntax.ArrayType
+arrayTypeElement :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.Type
+arrayTypeElement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ArrayType"),
+        Core.projectionFieldName = (Core.Name "element")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the length field of hydra.go.syntax.ArrayType
+arrayTypeLength :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.Expression
+arrayTypeLength x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ArrayType"),
+        Core.projectionFieldName = (Core.Name "length")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the element field of hydra.go.syntax.ArrayType
+arrayTypeWithElement :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ArrayType
+arrayTypeWithElement original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ArrayType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "length"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ArrayType"),
+              Core.projectionFieldName = (Core.Name "length")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the length field of hydra.go.syntax.ArrayType
+arrayTypeWithLength :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ArrayType
+arrayTypeWithLength original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ArrayType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "length"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ArrayType"),
+              Core.projectionFieldName = (Core.Name "element")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the add variant of hydra.go.syntax.AssignOp
+assignOpAdd :: Typed.TypedTerm Syntax.AddOp -> Typed.TypedTerm Syntax.AssignOp
+assignOpAdd x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.AssignOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "add"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the mul variant of hydra.go.syntax.AssignOp
+assignOpMul :: Typed.TypedTerm Syntax.MulOp -> Typed.TypedTerm Syntax.AssignOp
+assignOpMul x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.AssignOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "mul"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.go.syntax.AssignOp
+assignOpSimple :: Typed.TypedTerm Syntax.AssignOp
+assignOpSimple =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.AssignOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.go.syntax.Assignment
+assignment :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.AssignOp -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Assignment
+assignment lhs op rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm op)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.go.syntax.Assignment
+assignmentLhs :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm [Syntax.Expression]
+assignmentLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the op field of hydra.go.syntax.Assignment
+assignmentOp :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignOp
+assignmentOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.go.syntax.Assignment
+assignmentRhs :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm [Syntax.Expression]
+assignmentRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.go.syntax.Assignment
+assignmentWithLhs :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Assignment
+assignmentWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the op field of hydra.go.syntax.Assignment
+assignmentWithOp :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignOp -> Typed.TypedTerm Syntax.Assignment
+assignmentWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.go.syntax.Assignment
+assignmentWithRhs :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Assignment
+assignmentWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the float variant of hydra.go.syntax.BasicLit
+basicLitFloat :: Typed.TypedTerm Syntax.FloatLit -> Typed.TypedTerm Syntax.BasicLit
+basicLitFloat x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BasicLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "float"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the imaginary variant of hydra.go.syntax.BasicLit
+basicLitImaginary :: Typed.TypedTerm Syntax.ImaginaryLit -> Typed.TypedTerm Syntax.BasicLit
+basicLitImaginary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BasicLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "imaginary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the int variant of hydra.go.syntax.BasicLit
+basicLitInt :: Typed.TypedTerm Syntax.IntLit -> Typed.TypedTerm Syntax.BasicLit
+basicLitInt x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BasicLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "int"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the rune variant of hydra.go.syntax.BasicLit
+basicLitRune :: Typed.TypedTerm Syntax.RuneLit -> Typed.TypedTerm Syntax.BasicLit
+basicLitRune x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BasicLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "rune"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the string variant of hydra.go.syntax.BasicLit
+basicLitString :: Typed.TypedTerm Syntax.StringLit -> Typed.TypedTerm Syntax.BasicLit
+basicLitString x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BasicLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "string"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.BinaryExpr
+binaryExpr :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.BinaryOp -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.BinaryExpr
+binaryExpr left op right =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "left"),
+          Core.fieldTerm = (Typed.unTypedTerm left)},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm op)},
+        Core.Field {
+          Core.fieldName = (Core.Name "right"),
+          Core.fieldTerm = (Typed.unTypedTerm right)}]}))
+
+-- | DSL accessor for the left field of hydra.go.syntax.BinaryExpr
+binaryExprLeft :: Typed.TypedTerm Syntax.BinaryExpr -> Typed.TypedTerm Syntax.Expression
+binaryExprLeft x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+        Core.projectionFieldName = (Core.Name "left")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the op field of hydra.go.syntax.BinaryExpr
+binaryExprOp :: Typed.TypedTerm Syntax.BinaryExpr -> Typed.TypedTerm Syntax.BinaryOp
+binaryExprOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the right field of hydra.go.syntax.BinaryExpr
+binaryExprRight :: Typed.TypedTerm Syntax.BinaryExpr -> Typed.TypedTerm Syntax.Expression
+binaryExprRight x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+        Core.projectionFieldName = (Core.Name "right")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the left field of hydra.go.syntax.BinaryExpr
+binaryExprWithLeft :: Typed.TypedTerm Syntax.BinaryExpr -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.BinaryExpr
+binaryExprWithLeft original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "left"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "right"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+              Core.projectionFieldName = (Core.Name "right")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the op field of hydra.go.syntax.BinaryExpr
+binaryExprWithOp :: Typed.TypedTerm Syntax.BinaryExpr -> Typed.TypedTerm Syntax.BinaryOp -> Typed.TypedTerm Syntax.BinaryExpr
+binaryExprWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "left"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+              Core.projectionFieldName = (Core.Name "left")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "right"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+              Core.projectionFieldName = (Core.Name "right")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the right field of hydra.go.syntax.BinaryExpr
+binaryExprWithRight :: Typed.TypedTerm Syntax.BinaryExpr -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.BinaryExpr
+binaryExprWithRight original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "left"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+              Core.projectionFieldName = (Core.Name "left")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.BinaryExpr"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "right"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the add variant of hydra.go.syntax.BinaryOp
+binaryOpAdd :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpAdd =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "add"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the and variant of hydra.go.syntax.BinaryOp
+binaryOpAnd :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpAnd =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "and"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the bitClear variant of hydra.go.syntax.BinaryOp
+binaryOpBitClear :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpBitClear =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bitClear"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the bitwiseAnd variant of hydra.go.syntax.BinaryOp
+binaryOpBitwiseAnd :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpBitwiseAnd =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bitwiseAnd"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the bitwiseOr variant of hydra.go.syntax.BinaryOp
+binaryOpBitwiseOr :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpBitwiseOr =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bitwiseOr"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the bitwiseXor variant of hydra.go.syntax.BinaryOp
+binaryOpBitwiseXor :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpBitwiseXor =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bitwiseXor"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the divide variant of hydra.go.syntax.BinaryOp
+binaryOpDivide :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpDivide =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "divide"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the equal variant of hydra.go.syntax.BinaryOp
+binaryOpEqual :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpEqual =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "equal"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the greater variant of hydra.go.syntax.BinaryOp
+binaryOpGreater :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpGreater =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "greater"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the greaterEqual variant of hydra.go.syntax.BinaryOp
+binaryOpGreaterEqual :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpGreaterEqual =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "greaterEqual"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the leftShift variant of hydra.go.syntax.BinaryOp
+binaryOpLeftShift :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpLeftShift =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "leftShift"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the less variant of hydra.go.syntax.BinaryOp
+binaryOpLess :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpLess =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "less"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the lessEqual variant of hydra.go.syntax.BinaryOp
+binaryOpLessEqual :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpLessEqual =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lessEqual"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the multiply variant of hydra.go.syntax.BinaryOp
+binaryOpMultiply :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpMultiply =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "multiply"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the notEqual variant of hydra.go.syntax.BinaryOp
+binaryOpNotEqual :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpNotEqual =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "notEqual"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the or variant of hydra.go.syntax.BinaryOp
+binaryOpOr :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpOr =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "or"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the remainder variant of hydra.go.syntax.BinaryOp
+binaryOpRemainder :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpRemainder =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "remainder"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the rightShift variant of hydra.go.syntax.BinaryOp
+binaryOpRightShift :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpRightShift =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "rightShift"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the subtract variant of hydra.go.syntax.BinaryOp
+binaryOpSubtract :: Typed.TypedTerm Syntax.BinaryOp
+binaryOpSubtract =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.BinaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "subtract"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.go.syntax.Block wrapper
+block :: Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.Block
+block x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.Block"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.BreakStmt wrapper
+breakStmt :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.BreakStmt
+breakStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.BreakStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.CallExpr
+callExpr :: Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm Syntax.CallExpr
+callExpr function arguments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CallExpr"),
+      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.go.syntax.CallExpr
+callExprArguments :: Typed.TypedTerm Syntax.CallExpr -> Typed.TypedTerm Syntax.Arguments
+callExprArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.CallExpr"),
+        Core.projectionFieldName = (Core.Name "arguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the function field of hydra.go.syntax.CallExpr
+callExprFunction :: Typed.TypedTerm Syntax.CallExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+callExprFunction x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.CallExpr"),
+        Core.projectionFieldName = (Core.Name "function")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the arguments field of hydra.go.syntax.CallExpr
+callExprWithArguments :: Typed.TypedTerm Syntax.CallExpr -> Typed.TypedTerm Syntax.Arguments -> Typed.TypedTerm Syntax.CallExpr
+callExprWithArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CallExpr"),
+      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.go.syntax.CallExpr"),
+              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.go.syntax.CallExpr
+callExprWithFunction :: Typed.TypedTerm Syntax.CallExpr -> Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.CallExpr
+callExprWithFunction original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CallExpr"),
+      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.go.syntax.CallExpr"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the bidirectional variant of hydra.go.syntax.ChannelDirection
+channelDirectionBidirectional :: Typed.TypedTerm Syntax.ChannelDirection
+channelDirectionBidirectional =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ChannelDirection"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bidirectional"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the receive variant of hydra.go.syntax.ChannelDirection
+channelDirectionReceive :: Typed.TypedTerm Syntax.ChannelDirection
+channelDirectionReceive =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ChannelDirection"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "receive"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the send variant of hydra.go.syntax.ChannelDirection
+channelDirectionSend :: Typed.TypedTerm Syntax.ChannelDirection
+channelDirectionSend =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ChannelDirection"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "send"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.go.syntax.ChannelType
+channelType :: Typed.TypedTerm Syntax.ChannelDirection -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ChannelType
+channelType direction element =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ChannelType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "direction"),
+          Core.fieldTerm = (Typed.unTypedTerm direction)},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Typed.unTypedTerm element)}]}))
+
+-- | DSL accessor for the direction field of hydra.go.syntax.ChannelType
+channelTypeDirection :: Typed.TypedTerm Syntax.ChannelType -> Typed.TypedTerm Syntax.ChannelDirection
+channelTypeDirection x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ChannelType"),
+        Core.projectionFieldName = (Core.Name "direction")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the element field of hydra.go.syntax.ChannelType
+channelTypeElement :: Typed.TypedTerm Syntax.ChannelType -> Typed.TypedTerm Syntax.Type
+channelTypeElement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ChannelType"),
+        Core.projectionFieldName = (Core.Name "element")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the direction field of hydra.go.syntax.ChannelType
+channelTypeWithDirection :: Typed.TypedTerm Syntax.ChannelType -> Typed.TypedTerm Syntax.ChannelDirection -> Typed.TypedTerm Syntax.ChannelType
+channelTypeWithDirection original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ChannelType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "direction"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ChannelType"),
+              Core.projectionFieldName = (Core.Name "element")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the element field of hydra.go.syntax.ChannelType
+channelTypeWithElement :: Typed.TypedTerm Syntax.ChannelType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ChannelType
+channelTypeWithElement original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ChannelType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "direction"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ChannelType"),
+              Core.projectionFieldName = (Core.Name "direction")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the default variant of hydra.go.syntax.CommCase
+commCaseDefault :: Typed.TypedTerm Syntax.CommCase
+commCaseDefault =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.CommCase"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "default"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the receive variant of hydra.go.syntax.CommCase
+commCaseReceive :: Typed.TypedTerm Syntax.ReceiveCase -> Typed.TypedTerm Syntax.CommCase
+commCaseReceive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.CommCase"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "receive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the send variant of hydra.go.syntax.CommCase
+commCaseSend :: Typed.TypedTerm Syntax.SendStmt -> Typed.TypedTerm Syntax.CommCase
+commCaseSend x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.CommCase"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "send"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.CommClause
+commClause :: Typed.TypedTerm Syntax.CommCase -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.CommClause
+commClause case_ statements =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CommClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Typed.unTypedTerm case_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm statements)}]}))
+
+-- | DSL accessor for the case field of hydra.go.syntax.CommClause
+commClauseCase :: Typed.TypedTerm Syntax.CommClause -> Typed.TypedTerm Syntax.CommCase
+commClauseCase x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.CommClause"),
+        Core.projectionFieldName = (Core.Name "case")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the statements field of hydra.go.syntax.CommClause
+commClauseStatements :: Typed.TypedTerm Syntax.CommClause -> Typed.TypedTerm [Syntax.Statement]
+commClauseStatements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.CommClause"),
+        Core.projectionFieldName = (Core.Name "statements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the case field of hydra.go.syntax.CommClause
+commClauseWithCase :: Typed.TypedTerm Syntax.CommClause -> Typed.TypedTerm Syntax.CommCase -> Typed.TypedTerm Syntax.CommClause
+commClauseWithCase original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CommClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.CommClause"),
+              Core.projectionFieldName = (Core.Name "statements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statements field of hydra.go.syntax.CommClause
+commClauseWithStatements :: Typed.TypedTerm Syntax.CommClause -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.CommClause
+commClauseWithStatements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CommClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.CommClause"),
+              Core.projectionFieldName = (Core.Name "case")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.CompositeLit
+compositeLit :: Typed.TypedTerm Syntax.LiteralType -> Typed.TypedTerm Syntax.LiteralValue -> Typed.TypedTerm Syntax.CompositeLit
+compositeLit type_ value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CompositeLit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.CompositeLit
+compositeLitType :: Typed.TypedTerm Syntax.CompositeLit -> Typed.TypedTerm Syntax.LiteralType
+compositeLitType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.CompositeLit"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.go.syntax.CompositeLit
+compositeLitValue :: Typed.TypedTerm Syntax.CompositeLit -> Typed.TypedTerm Syntax.LiteralValue
+compositeLitValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.CompositeLit"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the type field of hydra.go.syntax.CompositeLit
+compositeLitWithType :: Typed.TypedTerm Syntax.CompositeLit -> Typed.TypedTerm Syntax.LiteralType -> Typed.TypedTerm Syntax.CompositeLit
+compositeLitWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CompositeLit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          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.go.syntax.CompositeLit"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.go.syntax.CompositeLit
+compositeLitWithValue :: Typed.TypedTerm Syntax.CompositeLit -> Typed.TypedTerm Syntax.LiteralValue -> Typed.TypedTerm Syntax.CompositeLit
+compositeLitWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.CompositeLit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.CompositeLit"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.go.syntax.ConstDecl wrapper
+constDecl :: Typed.TypedTerm [Syntax.ConstSpec] -> Typed.TypedTerm Syntax.ConstDecl
+constDecl x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.ConstDecl"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.ConstSpec
+constSpec :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ConstSpec
+constSpec names type_ values =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm names)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Typed.unTypedTerm values)}]}))
+
+-- | DSL accessor for the names field of hydra.go.syntax.ConstSpec
+constSpecNames :: Typed.TypedTerm Syntax.ConstSpec -> Typed.TypedTerm [Syntax.Identifier]
+constSpecNames x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+        Core.projectionFieldName = (Core.Name "names")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.ConstSpec
+constSpecType :: Typed.TypedTerm Syntax.ConstSpec -> Typed.TypedTerm (Maybe Syntax.Type)
+constSpecType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the values field of hydra.go.syntax.ConstSpec
+constSpecValues :: Typed.TypedTerm Syntax.ConstSpec -> Typed.TypedTerm [Syntax.Expression]
+constSpecValues x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+        Core.projectionFieldName = (Core.Name "values")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the names field of hydra.go.syntax.ConstSpec
+constSpecWithNames :: Typed.TypedTerm Syntax.ConstSpec -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.ConstSpec
+constSpecWithNames original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          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.go.syntax.ConstSpec"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+              Core.projectionFieldName = (Core.Name "values")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.ConstSpec
+constSpecWithType :: Typed.TypedTerm Syntax.ConstSpec -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.ConstSpec
+constSpecWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+              Core.projectionFieldName = (Core.Name "values")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the values field of hydra.go.syntax.ConstSpec
+constSpecWithValues :: Typed.TypedTerm Syntax.ConstSpec -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ConstSpec
+constSpecWithValues original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ConstSpec"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.go.syntax.ContinueStmt wrapper
+continueStmt :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ContinueStmt
+continueStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.ContinueStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.Conversion
+conversion :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Conversion
+conversion type_ expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Conversion"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.go.syntax.Conversion
+conversionExpression :: Typed.TypedTerm Syntax.Conversion -> Typed.TypedTerm Syntax.Expression
+conversionExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Conversion"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.Conversion
+conversionType :: Typed.TypedTerm Syntax.Conversion -> Typed.TypedTerm Syntax.Type
+conversionType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Conversion"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.go.syntax.Conversion
+conversionWithExpression :: Typed.TypedTerm Syntax.Conversion -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Conversion
+conversionWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Conversion"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Conversion"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.Conversion
+conversionWithType :: Typed.TypedTerm Syntax.Conversion -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Conversion
+conversionWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Conversion"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Conversion"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the const variant of hydra.go.syntax.Declaration
+declarationConst :: Typed.TypedTerm Syntax.ConstDecl -> Typed.TypedTerm Syntax.Declaration
+declarationConst x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Declaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "const"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.go.syntax.Declaration
+declarationType :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.Declaration
+declarationType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Declaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the var variant of hydra.go.syntax.Declaration
+declarationVar :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm Syntax.Declaration
+declarationVar x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Declaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "var"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.DeferStmt wrapper
+deferStmt :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DeferStmt
+deferStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.DeferStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the expression variant of hydra.go.syntax.Element
+elementExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Element
+elementExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Element"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.ElementList wrapper
+elementList :: Typed.TypedTerm [Syntax.KeyedElement] -> Typed.TypedTerm Syntax.ElementList
+elementList x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.ElementList"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the literal variant of hydra.go.syntax.Element
+elementLiteral :: Typed.TypedTerm Syntax.LiteralValue -> Typed.TypedTerm Syntax.Element
+elementLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Element"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the block variant of hydra.go.syntax.ElseClause
+elseClauseBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ElseClause
+elseClauseBlock x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ElseClause"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "block"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the if variant of hydra.go.syntax.ElseClause
+elseClauseIf :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm Syntax.ElseClause
+elseClauseIf x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ElseClause"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "if"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.EmbeddedField
+embeddedField :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm (Maybe Syntax.Tag) -> Typed.TypedTerm Syntax.EmbeddedField
+embeddedField pointer type_ tag =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pointer"),
+          Core.fieldTerm = (Typed.unTypedTerm pointer)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tag"),
+          Core.fieldTerm = (Typed.unTypedTerm tag)}]}))
+
+-- | DSL accessor for the pointer field of hydra.go.syntax.EmbeddedField
+embeddedFieldPointer :: Typed.TypedTerm Syntax.EmbeddedField -> Typed.TypedTerm Bool
+embeddedFieldPointer x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+        Core.projectionFieldName = (Core.Name "pointer")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tag field of hydra.go.syntax.EmbeddedField
+embeddedFieldTag :: Typed.TypedTerm Syntax.EmbeddedField -> Typed.TypedTerm (Maybe Syntax.Tag)
+embeddedFieldTag x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+        Core.projectionFieldName = (Core.Name "tag")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.EmbeddedField
+embeddedFieldType :: Typed.TypedTerm Syntax.EmbeddedField -> Typed.TypedTerm Syntax.TypeName
+embeddedFieldType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the pointer field of hydra.go.syntax.EmbeddedField
+embeddedFieldWithPointer :: Typed.TypedTerm Syntax.EmbeddedField -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.EmbeddedField
+embeddedFieldWithPointer original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pointer"),
+          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.go.syntax.EmbeddedField"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tag"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+              Core.projectionFieldName = (Core.Name "tag")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tag field of hydra.go.syntax.EmbeddedField
+embeddedFieldWithTag :: Typed.TypedTerm Syntax.EmbeddedField -> Typed.TypedTerm (Maybe Syntax.Tag) -> Typed.TypedTerm Syntax.EmbeddedField
+embeddedFieldWithTag original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pointer"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+              Core.projectionFieldName = (Core.Name "pointer")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tag"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.EmbeddedField
+embeddedFieldWithType :: Typed.TypedTerm Syntax.EmbeddedField -> Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.EmbeddedField
+embeddedFieldWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pointer"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+              Core.projectionFieldName = (Core.Name "pointer")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tag"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.EmbeddedField"),
+              Core.projectionFieldName = (Core.Name "tag")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.go.syntax.EmptyStmt wrapper
+emptyStmt :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.EmptyStmt
+emptyStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.EmptyStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.ExprCaseClause
+exprCaseClause :: Typed.TypedTerm (Maybe [Syntax.Expression]) -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.ExprCaseClause
+exprCaseClause case_ statements =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ExprCaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Typed.unTypedTerm case_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm statements)}]}))
+
+-- | DSL accessor for the case field of hydra.go.syntax.ExprCaseClause
+exprCaseClauseCase :: Typed.TypedTerm Syntax.ExprCaseClause -> Typed.TypedTerm (Maybe [Syntax.Expression])
+exprCaseClauseCase x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprCaseClause"),
+        Core.projectionFieldName = (Core.Name "case")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the statements field of hydra.go.syntax.ExprCaseClause
+exprCaseClauseStatements :: Typed.TypedTerm Syntax.ExprCaseClause -> Typed.TypedTerm [Syntax.Statement]
+exprCaseClauseStatements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprCaseClause"),
+        Core.projectionFieldName = (Core.Name "statements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the case field of hydra.go.syntax.ExprCaseClause
+exprCaseClauseWithCase :: Typed.TypedTerm Syntax.ExprCaseClause -> Typed.TypedTerm (Maybe [Syntax.Expression]) -> Typed.TypedTerm Syntax.ExprCaseClause
+exprCaseClauseWithCase original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ExprCaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprCaseClause"),
+              Core.projectionFieldName = (Core.Name "statements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statements field of hydra.go.syntax.ExprCaseClause
+exprCaseClauseWithStatements :: Typed.TypedTerm Syntax.ExprCaseClause -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.ExprCaseClause
+exprCaseClauseWithStatements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ExprCaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprCaseClause"),
+              Core.projectionFieldName = (Core.Name "case")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.ExprSwitchStmt
+exprSwitchStmt :: Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm [Syntax.ExprCaseClause] -> Typed.TypedTerm Syntax.ExprSwitchStmt
+exprSwitchStmt init expression cases =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm init)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))
+
+-- | DSL accessor for the cases field of hydra.go.syntax.ExprSwitchStmt
+exprSwitchStmtCases :: Typed.TypedTerm Syntax.ExprSwitchStmt -> Typed.TypedTerm [Syntax.ExprCaseClause]
+exprSwitchStmtCases x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+        Core.projectionFieldName = (Core.Name "cases")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expression field of hydra.go.syntax.ExprSwitchStmt
+exprSwitchStmtExpression :: Typed.TypedTerm Syntax.ExprSwitchStmt -> Typed.TypedTerm (Maybe Syntax.Expression)
+exprSwitchStmtExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the init field of hydra.go.syntax.ExprSwitchStmt
+exprSwitchStmtInit :: Typed.TypedTerm Syntax.ExprSwitchStmt -> Typed.TypedTerm (Maybe Syntax.SimpleStmt)
+exprSwitchStmtInit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+        Core.projectionFieldName = (Core.Name "init")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cases field of hydra.go.syntax.ExprSwitchStmt
+exprSwitchStmtWithCases :: Typed.TypedTerm Syntax.ExprSwitchStmt -> Typed.TypedTerm [Syntax.ExprCaseClause] -> Typed.TypedTerm Syntax.ExprSwitchStmt
+exprSwitchStmtWithCases original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the expression field of hydra.go.syntax.ExprSwitchStmt
+exprSwitchStmtWithExpression :: Typed.TypedTerm Syntax.ExprSwitchStmt -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.ExprSwitchStmt
+exprSwitchStmtWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "cases")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the init field of hydra.go.syntax.ExprSwitchStmt
+exprSwitchStmtWithInit :: Typed.TypedTerm Syntax.ExprSwitchStmt -> Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm Syntax.ExprSwitchStmt
+exprSwitchStmtWithInit original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ExprSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "cases")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the binary variant of hydra.go.syntax.Expression
+expressionBinary :: Typed.TypedTerm Syntax.BinaryExpr -> Typed.TypedTerm Syntax.Expression
+expressionBinary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "binary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.ExpressionStmt wrapper
+expressionStmt :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ExpressionStmt
+expressionStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.ExpressionStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the unary variant of hydra.go.syntax.Expression
+expressionUnary :: Typed.TypedTerm Syntax.UnaryExpr -> Typed.TypedTerm Syntax.Expression
+expressionUnary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.FallthroughStmt wrapper
+fallthroughStmt :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.FallthroughStmt
+fallthroughStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.FallthroughStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the embedded variant of hydra.go.syntax.FieldDecl
+fieldDeclEmbedded :: Typed.TypedTerm Syntax.EmbeddedField -> Typed.TypedTerm Syntax.FieldDecl
+fieldDeclEmbedded x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.FieldDecl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "embedded"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the named variant of hydra.go.syntax.FieldDecl
+fieldDeclNamed :: Typed.TypedTerm Syntax.NamedField -> Typed.TypedTerm Syntax.FieldDecl
+fieldDeclNamed x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.FieldDecl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "named"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.FloatLit wrapper
+floatLit :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.FloatLit
+floatLit x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.FloatLit"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.ForClause
+forClause :: Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm Syntax.ForClause
+forClause init condition post =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm init)},
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Typed.unTypedTerm condition)},
+        Core.Field {
+          Core.fieldName = (Core.Name "post"),
+          Core.fieldTerm = (Typed.unTypedTerm post)}]}))
+
+-- | DSL accessor for the condition field of hydra.go.syntax.ForClause
+forClauseCondition :: Typed.TypedTerm Syntax.ForClause -> Typed.TypedTerm (Maybe Syntax.Expression)
+forClauseCondition x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+        Core.projectionFieldName = (Core.Name "condition")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the init field of hydra.go.syntax.ForClause
+forClauseInit :: Typed.TypedTerm Syntax.ForClause -> Typed.TypedTerm (Maybe Syntax.SimpleStmt)
+forClauseInit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+        Core.projectionFieldName = (Core.Name "init")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the clause variant of hydra.go.syntax.ForClauseOrRange
+forClauseOrRangeClause :: Typed.TypedTerm Syntax.ForClause -> Typed.TypedTerm Syntax.ForClauseOrRange
+forClauseOrRangeClause x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ForClauseOrRange"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "clause"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the condition variant of hydra.go.syntax.ForClauseOrRange
+forClauseOrRangeCondition :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForClauseOrRange
+forClauseOrRangeCondition x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ForClauseOrRange"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "condition"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the range variant of hydra.go.syntax.ForClauseOrRange
+forClauseOrRangeRange :: Typed.TypedTerm Syntax.RangeClause -> Typed.TypedTerm Syntax.ForClauseOrRange
+forClauseOrRangeRange x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ForClauseOrRange"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "range"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL accessor for the post field of hydra.go.syntax.ForClause
+forClausePost :: Typed.TypedTerm Syntax.ForClause -> Typed.TypedTerm (Maybe Syntax.SimpleStmt)
+forClausePost x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+        Core.projectionFieldName = (Core.Name "post")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the condition field of hydra.go.syntax.ForClause
+forClauseWithCondition :: Typed.TypedTerm Syntax.ForClause -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.ForClause
+forClauseWithCondition original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "post"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+              Core.projectionFieldName = (Core.Name "post")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the init field of hydra.go.syntax.ForClause
+forClauseWithInit :: Typed.TypedTerm Syntax.ForClause -> Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm Syntax.ForClause
+forClauseWithInit original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+              Core.projectionFieldName = (Core.Name "condition")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "post"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+              Core.projectionFieldName = (Core.Name "post")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the post field of hydra.go.syntax.ForClause
+forClauseWithPost :: Typed.TypedTerm Syntax.ForClause -> Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm Syntax.ForClause
+forClauseWithPost original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForClause"),
+              Core.projectionFieldName = (Core.Name "condition")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "post"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.ForStmt
+forStmt :: Typed.TypedTerm (Maybe Syntax.ForClauseOrRange) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ForStmt
+forStmt clause body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ForStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "clause"),
+          Core.fieldTerm = (Typed.unTypedTerm clause)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.go.syntax.ForStmt
+forStmtBody :: Typed.TypedTerm Syntax.ForStmt -> Typed.TypedTerm Syntax.Block
+forStmtBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForStmt"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the clause field of hydra.go.syntax.ForStmt
+forStmtClause :: Typed.TypedTerm Syntax.ForStmt -> Typed.TypedTerm (Maybe Syntax.ForClauseOrRange)
+forStmtClause x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForStmt"),
+        Core.projectionFieldName = (Core.Name "clause")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.go.syntax.ForStmt
+forStmtWithBody :: Typed.TypedTerm Syntax.ForStmt -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ForStmt
+forStmtWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ForStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "clause"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ForStmt"),
+              Core.projectionFieldName = (Core.Name "clause")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the clause field of hydra.go.syntax.ForStmt
+forStmtWithClause :: Typed.TypedTerm Syntax.ForStmt -> Typed.TypedTerm (Maybe Syntax.ForClauseOrRange) -> Typed.TypedTerm Syntax.ForStmt
+forStmtWithClause original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ForStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "clause"),
+          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.go.syntax.ForStmt"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.FullSlice
+fullSlice :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FullSlice
+fullSlice low high max =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "low"),
+          Core.fieldTerm = (Typed.unTypedTerm low)},
+        Core.Field {
+          Core.fieldName = (Core.Name "high"),
+          Core.fieldTerm = (Typed.unTypedTerm high)},
+        Core.Field {
+          Core.fieldName = (Core.Name "max"),
+          Core.fieldTerm = (Typed.unTypedTerm max)}]}))
+
+-- | DSL accessor for the high field of hydra.go.syntax.FullSlice
+fullSliceHigh :: Typed.TypedTerm Syntax.FullSlice -> Typed.TypedTerm Syntax.Expression
+fullSliceHigh x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+        Core.projectionFieldName = (Core.Name "high")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the low field of hydra.go.syntax.FullSlice
+fullSliceLow :: Typed.TypedTerm Syntax.FullSlice -> Typed.TypedTerm (Maybe Syntax.Expression)
+fullSliceLow x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+        Core.projectionFieldName = (Core.Name "low")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the max field of hydra.go.syntax.FullSlice
+fullSliceMax :: Typed.TypedTerm Syntax.FullSlice -> Typed.TypedTerm Syntax.Expression
+fullSliceMax x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+        Core.projectionFieldName = (Core.Name "max")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the high field of hydra.go.syntax.FullSlice
+fullSliceWithHigh :: Typed.TypedTerm Syntax.FullSlice -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FullSlice
+fullSliceWithHigh original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "low"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+              Core.projectionFieldName = (Core.Name "low")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "high"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "max"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+              Core.projectionFieldName = (Core.Name "max")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the low field of hydra.go.syntax.FullSlice
+fullSliceWithLow :: Typed.TypedTerm Syntax.FullSlice -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.FullSlice
+fullSliceWithLow original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "low"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "high"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+              Core.projectionFieldName = (Core.Name "high")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "max"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+              Core.projectionFieldName = (Core.Name "max")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the max field of hydra.go.syntax.FullSlice
+fullSliceWithMax :: Typed.TypedTerm Syntax.FullSlice -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FullSlice
+fullSliceWithMax original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "low"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+              Core.projectionFieldName = (Core.Name "low")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "high"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FullSlice"),
+              Core.projectionFieldName = (Core.Name "high")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "max"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.go.syntax.FunctionBody wrapper
+functionBody :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.FunctionBody
+functionBody x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.FunctionBody"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.FunctionDecl
+functionDecl :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeParameters) -> Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm (Maybe Syntax.FunctionBody) -> Typed.TypedTerm Syntax.FunctionDecl
+functionDecl name typeParams signature body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          Core.fieldTerm = (Typed.unTypedTerm typeParams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Typed.unTypedTerm signature)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.go.syntax.FunctionDecl
+functionDeclBody :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm (Maybe Syntax.FunctionBody)
+functionDeclBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.go.syntax.FunctionDecl
+functionDeclName :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm Syntax.Identifier
+functionDeclName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the signature field of hydra.go.syntax.FunctionDecl
+functionDeclSignature :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm Syntax.Signature
+functionDeclSignature x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+        Core.projectionFieldName = (Core.Name "signature")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeParams field of hydra.go.syntax.FunctionDecl
+functionDeclTypeParams :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm (Maybe Syntax.TypeParameters)
+functionDeclTypeParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+        Core.projectionFieldName = (Core.Name "typeParams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.go.syntax.FunctionDecl
+functionDeclWithBody :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm (Maybe Syntax.FunctionBody) -> Typed.TypedTerm Syntax.FunctionDecl
+functionDeclWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+      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.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "typeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "signature")})),
+            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.go.syntax.FunctionDecl
+functionDeclWithName :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FunctionDecl
+functionDeclWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "typeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "signature")})),
+            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.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the signature field of hydra.go.syntax.FunctionDecl
+functionDeclWithSignature :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.FunctionDecl
+functionDeclWithSignature original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+      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.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "typeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          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.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeParams field of hydra.go.syntax.FunctionDecl
+functionDeclWithTypeParams :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm (Maybe Syntax.TypeParameters) -> Typed.TypedTerm Syntax.FunctionDecl
+functionDeclWithTypeParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+      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.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "signature")})),
+            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.go.syntax.FunctionDecl"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.FunctionLit
+functionLit :: Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.FunctionLit
+functionLit signature body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FunctionLit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Typed.unTypedTerm signature)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.go.syntax.FunctionLit
+functionLitBody :: Typed.TypedTerm Syntax.FunctionLit -> Typed.TypedTerm Syntax.FunctionBody
+functionLitBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionLit"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the signature field of hydra.go.syntax.FunctionLit
+functionLitSignature :: Typed.TypedTerm Syntax.FunctionLit -> Typed.TypedTerm Syntax.Signature
+functionLitSignature x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionLit"),
+        Core.projectionFieldName = (Core.Name "signature")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.go.syntax.FunctionLit
+functionLitWithBody :: Typed.TypedTerm Syntax.FunctionLit -> Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.FunctionLit
+functionLitWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FunctionLit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.FunctionLit"),
+              Core.projectionFieldName = (Core.Name "signature")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the signature field of hydra.go.syntax.FunctionLit
+functionLitWithSignature :: Typed.TypedTerm Syntax.FunctionLit -> Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.FunctionLit
+functionLitWithSignature original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.FunctionLit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          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.go.syntax.FunctionLit"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.go.syntax.FunctionType wrapper
+functionType :: Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.FunctionType
+functionType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.FunctionType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.GoStmt wrapper
+goStmt :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.GoStmt
+goStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.GoStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.GotoStmt wrapper
+gotoStmt :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.GotoStmt
+gotoStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.GotoStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.Identifier wrapper
+identifier :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Identifier
+identifier x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.Identifier"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.IfStmt
+ifStmt :: Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.ElseClause) -> Typed.TypedTerm Syntax.IfStmt
+ifStmt init condition then_ else_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm init)},
+        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.go.syntax.IfStmt
+ifStmtCondition :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm Syntax.Expression
+ifStmtCondition x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+        Core.projectionFieldName = (Core.Name "condition")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the else field of hydra.go.syntax.IfStmt
+ifStmtElse :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm (Maybe Syntax.ElseClause)
+ifStmtElse x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+        Core.projectionFieldName = (Core.Name "else")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the init field of hydra.go.syntax.IfStmt
+ifStmtInit :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm (Maybe Syntax.SimpleStmt)
+ifStmtInit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+        Core.projectionFieldName = (Core.Name "init")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the then field of hydra.go.syntax.IfStmt
+ifStmtThen :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm Syntax.Block
+ifStmtThen x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+        Core.projectionFieldName = (Core.Name "then")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the condition field of hydra.go.syntax.IfStmt
+ifStmtWithCondition :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IfStmt
+ifStmtWithCondition original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        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.go.syntax.IfStmt"),
+              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.go.syntax.IfStmt"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the else field of hydra.go.syntax.IfStmt
+ifStmtWithElse :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm (Maybe Syntax.ElseClause) -> Typed.TypedTerm Syntax.IfStmt
+ifStmtWithElse original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+              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.go.syntax.IfStmt"),
+              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 init field of hydra.go.syntax.IfStmt
+ifStmtWithInit :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm Syntax.IfStmt
+ifStmtWithInit original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+              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.go.syntax.IfStmt"),
+              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.go.syntax.IfStmt"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the then field of hydra.go.syntax.IfStmt
+ifStmtWithThen :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.IfStmt
+ifStmtWithThen original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "condition"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IfStmt"),
+              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.go.syntax.IfStmt"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.go.syntax.ImaginaryLit wrapper
+imaginaryLit :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.ImaginaryLit
+imaginaryLit x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.ImaginaryLit"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the dot variant of hydra.go.syntax.ImportAlias
+importAliasDot :: Typed.TypedTerm Syntax.ImportAlias
+importAliasDot =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ImportAlias"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "dot"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the name variant of hydra.go.syntax.ImportAlias
+importAliasName :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ImportAlias
+importAliasName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.ImportAlias"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.ImportDecl wrapper
+importDecl :: Typed.TypedTerm [Syntax.ImportSpec] -> Typed.TypedTerm Syntax.ImportDecl
+importDecl x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.ImportDecl"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.ImportPath wrapper
+importPath :: Typed.TypedTerm Syntax.StringLit -> Typed.TypedTerm Syntax.ImportPath
+importPath x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.ImportPath"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.ImportSpec
+importSpec :: Typed.TypedTerm (Maybe Syntax.ImportAlias) -> Typed.TypedTerm Syntax.ImportPath -> Typed.TypedTerm Syntax.ImportSpec
+importSpec alias path =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ImportSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "alias"),
+          Core.fieldTerm = (Typed.unTypedTerm alias)},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Typed.unTypedTerm path)}]}))
+
+-- | DSL accessor for the alias field of hydra.go.syntax.ImportSpec
+importSpecAlias :: Typed.TypedTerm Syntax.ImportSpec -> Typed.TypedTerm (Maybe Syntax.ImportAlias)
+importSpecAlias x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ImportSpec"),
+        Core.projectionFieldName = (Core.Name "alias")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the path field of hydra.go.syntax.ImportSpec
+importSpecPath :: Typed.TypedTerm Syntax.ImportSpec -> Typed.TypedTerm Syntax.ImportPath
+importSpecPath x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ImportSpec"),
+        Core.projectionFieldName = (Core.Name "path")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the alias field of hydra.go.syntax.ImportSpec
+importSpecWithAlias :: Typed.TypedTerm Syntax.ImportSpec -> Typed.TypedTerm (Maybe Syntax.ImportAlias) -> Typed.TypedTerm Syntax.ImportSpec
+importSpecWithAlias original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ImportSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "alias"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ImportSpec"),
+              Core.projectionFieldName = (Core.Name "path")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the path field of hydra.go.syntax.ImportSpec
+importSpecWithPath :: Typed.TypedTerm Syntax.ImportSpec -> Typed.TypedTerm Syntax.ImportPath -> Typed.TypedTerm Syntax.ImportSpec
+importSpecWithPath original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ImportSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "alias"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ImportSpec"),
+              Core.projectionFieldName = (Core.Name "alias")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "path"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.IncDecStmt
+incDecStmt :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.IncDecStmt
+incDecStmt expression increment =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IncDecStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)},
+        Core.Field {
+          Core.fieldName = (Core.Name "increment"),
+          Core.fieldTerm = (Typed.unTypedTerm increment)}]}))
+
+-- | DSL accessor for the expression field of hydra.go.syntax.IncDecStmt
+incDecStmtExpression :: Typed.TypedTerm Syntax.IncDecStmt -> Typed.TypedTerm Syntax.Expression
+incDecStmtExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.IncDecStmt"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the increment field of hydra.go.syntax.IncDecStmt
+incDecStmtIncrement :: Typed.TypedTerm Syntax.IncDecStmt -> Typed.TypedTerm Bool
+incDecStmtIncrement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.IncDecStmt"),
+        Core.projectionFieldName = (Core.Name "increment")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.go.syntax.IncDecStmt
+incDecStmtWithExpression :: Typed.TypedTerm Syntax.IncDecStmt -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IncDecStmt
+incDecStmtWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IncDecStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "increment"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IncDecStmt"),
+              Core.projectionFieldName = (Core.Name "increment")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the increment field of hydra.go.syntax.IncDecStmt
+incDecStmtWithIncrement :: Typed.TypedTerm Syntax.IncDecStmt -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.IncDecStmt
+incDecStmtWithIncrement original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IncDecStmt"),
+      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.go.syntax.IncDecStmt"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "increment"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.go.syntax.Index wrapper
+index :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Index
+index x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.Index"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.IndexExpr
+indexExpr :: Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IndexExpr
+indexExpr expr index =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IndexExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "index"),
+          Core.fieldTerm = (Typed.unTypedTerm index)}]}))
+
+-- | DSL accessor for the expr field of hydra.go.syntax.IndexExpr
+indexExprExpr :: Typed.TypedTerm Syntax.IndexExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+indexExprExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.IndexExpr"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the index field of hydra.go.syntax.IndexExpr
+indexExprIndex :: Typed.TypedTerm Syntax.IndexExpr -> Typed.TypedTerm Syntax.Expression
+indexExprIndex x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.IndexExpr"),
+        Core.projectionFieldName = (Core.Name "index")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.go.syntax.IndexExpr
+indexExprWithExpr :: Typed.TypedTerm Syntax.IndexExpr -> Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.IndexExpr
+indexExprWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IndexExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "index"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IndexExpr"),
+              Core.projectionFieldName = (Core.Name "index")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the index field of hydra.go.syntax.IndexExpr
+indexExprWithIndex :: Typed.TypedTerm Syntax.IndexExpr -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IndexExpr
+indexExprWithIndex original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.IndexExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.IndexExpr"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "index"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.go.syntax.IntLit wrapper
+intLit :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.IntLit
+intLit x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.IntLit"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the method variant of hydra.go.syntax.InterfaceElem
+interfaceElemMethod :: Typed.TypedTerm Syntax.MethodElem -> Typed.TypedTerm Syntax.InterfaceElem
+interfaceElemMethod x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.InterfaceElem"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "method"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.go.syntax.InterfaceElem
+interfaceElemType :: Typed.TypedTerm Syntax.TypeElem -> Typed.TypedTerm Syntax.InterfaceElem
+interfaceElemType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.InterfaceElem"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.InterfaceType wrapper
+interfaceType :: Typed.TypedTerm [Syntax.InterfaceElem] -> Typed.TypedTerm Syntax.InterfaceType
+interfaceType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.InterfaceType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.InterpretedStringLit wrapper
+interpretedStringLit :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.InterpretedStringLit
+interpretedStringLit x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.InterpretedStringLit"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the expression variant of hydra.go.syntax.Key
+keyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Key
+keyExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Key"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the field variant of hydra.go.syntax.Key
+keyField :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Key
+keyField x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Key"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "field"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the literal variant of hydra.go.syntax.Key
+keyLiteral :: Typed.TypedTerm Syntax.LiteralValue -> Typed.TypedTerm Syntax.Key
+keyLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Key"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.KeyedElement
+keyedElement :: Typed.TypedTerm (Maybe Syntax.Key) -> Typed.TypedTerm Syntax.Element -> Typed.TypedTerm Syntax.KeyedElement
+keyedElement key element =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.KeyedElement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "key"),
+          Core.fieldTerm = (Typed.unTypedTerm key)},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Typed.unTypedTerm element)}]}))
+
+-- | DSL accessor for the element field of hydra.go.syntax.KeyedElement
+keyedElementElement :: Typed.TypedTerm Syntax.KeyedElement -> Typed.TypedTerm Syntax.Element
+keyedElementElement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.KeyedElement"),
+        Core.projectionFieldName = (Core.Name "element")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the key field of hydra.go.syntax.KeyedElement
+keyedElementKey :: Typed.TypedTerm Syntax.KeyedElement -> Typed.TypedTerm (Maybe Syntax.Key)
+keyedElementKey x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.KeyedElement"),
+        Core.projectionFieldName = (Core.Name "key")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the element field of hydra.go.syntax.KeyedElement
+keyedElementWithElement :: Typed.TypedTerm Syntax.KeyedElement -> Typed.TypedTerm Syntax.Element -> Typed.TypedTerm Syntax.KeyedElement
+keyedElementWithElement original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.KeyedElement"),
+      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.go.syntax.KeyedElement"),
+              Core.projectionFieldName = (Core.Name "key")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the key field of hydra.go.syntax.KeyedElement
+keyedElementWithKey :: Typed.TypedTerm Syntax.KeyedElement -> Typed.TypedTerm (Maybe Syntax.Key) -> Typed.TypedTerm Syntax.KeyedElement
+keyedElementWithKey original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.KeyedElement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "key"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "element"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.KeyedElement"),
+              Core.projectionFieldName = (Core.Name "element")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.LabeledStmt
+labeledStmt :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStmt
+labeledStmt label statement =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.LabeledStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "label"),
+          Core.fieldTerm = (Typed.unTypedTerm label)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Typed.unTypedTerm statement)}]}))
+
+-- | DSL accessor for the label field of hydra.go.syntax.LabeledStmt
+labeledStmtLabel :: Typed.TypedTerm Syntax.LabeledStmt -> Typed.TypedTerm Syntax.Identifier
+labeledStmtLabel x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.LabeledStmt"),
+        Core.projectionFieldName = (Core.Name "label")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the statement field of hydra.go.syntax.LabeledStmt
+labeledStmtStatement :: Typed.TypedTerm Syntax.LabeledStmt -> Typed.TypedTerm Syntax.Statement
+labeledStmtStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.LabeledStmt"),
+        Core.projectionFieldName = (Core.Name "statement")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the label field of hydra.go.syntax.LabeledStmt
+labeledStmtWithLabel :: Typed.TypedTerm Syntax.LabeledStmt -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LabeledStmt
+labeledStmtWithLabel original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.LabeledStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "label"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.LabeledStmt"),
+              Core.projectionFieldName = (Core.Name "statement")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statement field of hydra.go.syntax.LabeledStmt
+labeledStmtWithStatement :: Typed.TypedTerm Syntax.LabeledStmt -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStmt
+labeledStmtWithStatement original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.LabeledStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "label"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.LabeledStmt"),
+              Core.projectionFieldName = (Core.Name "label")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the basic variant of hydra.go.syntax.Literal
+literalBasic :: Typed.TypedTerm Syntax.BasicLit -> Typed.TypedTerm Syntax.Literal
+literalBasic x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "basic"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the composite variant of hydra.go.syntax.Literal
+literalComposite :: Typed.TypedTerm Syntax.CompositeLit -> Typed.TypedTerm Syntax.Literal
+literalComposite x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "composite"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the function variant of hydra.go.syntax.Literal
+literalFunction :: Typed.TypedTerm Syntax.FunctionLit -> Typed.TypedTerm Syntax.Literal
+literalFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "function"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the array variant of hydra.go.syntax.LiteralType
+literalTypeArray :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.LiteralType
+literalTypeArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.LiteralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "array"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the inferredArray variant of hydra.go.syntax.LiteralType
+literalTypeInferredArray :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LiteralType
+literalTypeInferredArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.LiteralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "inferredArray"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the map variant of hydra.go.syntax.LiteralType
+literalTypeMap :: Typed.TypedTerm Syntax.MapType -> Typed.TypedTerm Syntax.LiteralType
+literalTypeMap x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.LiteralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "map"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the name variant of hydra.go.syntax.LiteralType
+literalTypeName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.LiteralType
+literalTypeName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.LiteralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the slice variant of hydra.go.syntax.LiteralType
+literalTypeSlice :: Typed.TypedTerm Syntax.SliceType -> Typed.TypedTerm Syntax.LiteralType
+literalTypeSlice x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.LiteralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "slice"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the struct variant of hydra.go.syntax.LiteralType
+literalTypeStruct :: Typed.TypedTerm Syntax.StructType -> Typed.TypedTerm Syntax.LiteralType
+literalTypeStruct x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.LiteralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "struct"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.LiteralValue wrapper
+literalValue :: Typed.TypedTerm [Syntax.KeyedElement] -> Typed.TypedTerm Syntax.LiteralValue
+literalValue x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.LiteralValue"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.MapType
+mapType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MapType
+mapType key value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MapType"),
+      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.go.syntax.MapType
+mapTypeKey :: Typed.TypedTerm Syntax.MapType -> Typed.TypedTerm Syntax.Type
+mapTypeKey x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MapType"),
+        Core.projectionFieldName = (Core.Name "key")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.go.syntax.MapType
+mapTypeValue :: Typed.TypedTerm Syntax.MapType -> Typed.TypedTerm Syntax.Type
+mapTypeValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MapType"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the key field of hydra.go.syntax.MapType
+mapTypeWithKey :: Typed.TypedTerm Syntax.MapType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MapType
+mapTypeWithKey original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MapType"),
+      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.go.syntax.MapType"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.go.syntax.MapType
+mapTypeWithValue :: Typed.TypedTerm Syntax.MapType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MapType
+mapTypeWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MapType"),
+      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.go.syntax.MapType"),
+              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.go.syntax.MethodDecl
+methodDecl :: Typed.TypedTerm Syntax.Receiver -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm (Maybe Syntax.FunctionBody) -> Typed.TypedTerm Syntax.MethodDecl
+methodDecl receiver name signature body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "receiver"),
+          Core.fieldTerm = (Typed.unTypedTerm receiver)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Typed.unTypedTerm signature)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.go.syntax.MethodDecl
+methodDeclBody :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm (Maybe Syntax.FunctionBody)
+methodDeclBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.go.syntax.MethodDecl
+methodDeclName :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm Syntax.Identifier
+methodDeclName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the receiver field of hydra.go.syntax.MethodDecl
+methodDeclReceiver :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm Syntax.Receiver
+methodDeclReceiver x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+        Core.projectionFieldName = (Core.Name "receiver")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the signature field of hydra.go.syntax.MethodDecl
+methodDeclSignature :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm Syntax.Signature
+methodDeclSignature x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+        Core.projectionFieldName = (Core.Name "signature")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.go.syntax.MethodDecl
+methodDeclWithBody :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm (Maybe Syntax.FunctionBody) -> Typed.TypedTerm Syntax.MethodDecl
+methodDeclWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "receiver"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "receiver")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "signature")})),
+            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.go.syntax.MethodDecl
+methodDeclWithName :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodDecl
+methodDeclWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "receiver"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "receiver")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "signature")})),
+            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.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the receiver field of hydra.go.syntax.MethodDecl
+methodDeclWithReceiver :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm Syntax.Receiver -> Typed.TypedTerm Syntax.MethodDecl
+methodDeclWithReceiver original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "receiver"),
+          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.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "signature")})),
+            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.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the signature field of hydra.go.syntax.MethodDecl
+methodDeclWithSignature :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.MethodDecl
+methodDeclWithSignature original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "receiver"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "receiver")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          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.go.syntax.MethodDecl"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.MethodElem
+methodElem :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.MethodElem
+methodElem name signature =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodElem"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Typed.unTypedTerm signature)}]}))
+
+-- | DSL accessor for the name field of hydra.go.syntax.MethodElem
+methodElemName :: Typed.TypedTerm Syntax.MethodElem -> Typed.TypedTerm Syntax.Identifier
+methodElemName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodElem"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the signature field of hydra.go.syntax.MethodElem
+methodElemSignature :: Typed.TypedTerm Syntax.MethodElem -> Typed.TypedTerm Syntax.Signature
+methodElemSignature x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodElem"),
+        Core.projectionFieldName = (Core.Name "signature")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.go.syntax.MethodElem
+methodElemWithName :: Typed.TypedTerm Syntax.MethodElem -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodElem
+methodElemWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodElem"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodElem"),
+              Core.projectionFieldName = (Core.Name "signature")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the signature field of hydra.go.syntax.MethodElem
+methodElemWithSignature :: Typed.TypedTerm Syntax.MethodElem -> Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.MethodElem
+methodElemWithSignature original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodElem"),
+      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.go.syntax.MethodElem"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "signature"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.MethodExpr
+methodExpr :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodExpr
+methodExpr receiver method =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "receiver"),
+          Core.fieldTerm = (Typed.unTypedTerm receiver)},
+        Core.Field {
+          Core.fieldName = (Core.Name "method"),
+          Core.fieldTerm = (Typed.unTypedTerm method)}]}))
+
+-- | DSL accessor for the method field of hydra.go.syntax.MethodExpr
+methodExprMethod :: Typed.TypedTerm Syntax.MethodExpr -> Typed.TypedTerm Syntax.Identifier
+methodExprMethod x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodExpr"),
+        Core.projectionFieldName = (Core.Name "method")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the receiver field of hydra.go.syntax.MethodExpr
+methodExprReceiver :: Typed.TypedTerm Syntax.MethodExpr -> Typed.TypedTerm Syntax.Type
+methodExprReceiver x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodExpr"),
+        Core.projectionFieldName = (Core.Name "receiver")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the method field of hydra.go.syntax.MethodExpr
+methodExprWithMethod :: Typed.TypedTerm Syntax.MethodExpr -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodExpr
+methodExprWithMethod original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "receiver"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodExpr"),
+              Core.projectionFieldName = (Core.Name "receiver")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "method"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the receiver field of hydra.go.syntax.MethodExpr
+methodExprWithReceiver :: Typed.TypedTerm Syntax.MethodExpr -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MethodExpr
+methodExprWithReceiver original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.MethodExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "receiver"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "method"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.MethodExpr"),
+              Core.projectionFieldName = (Core.Name "method")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.Module
+module_ :: Typed.TypedTerm Syntax.PackageClause -> Typed.TypedTerm [Syntax.ImportDecl] -> Typed.TypedTerm [Syntax.TopLevelDecl] -> Typed.TypedTerm Syntax.Module
+module_ package imports declarations =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Module"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Typed.unTypedTerm package)},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Typed.unTypedTerm imports)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarations"),
+          Core.fieldTerm = (Typed.unTypedTerm declarations)}]}))
+
+-- | DSL accessor for the declarations field of hydra.go.syntax.Module
+moduleDeclarations :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.TopLevelDecl]
+moduleDeclarations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Module"),
+        Core.projectionFieldName = (Core.Name "declarations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the imports field of hydra.go.syntax.Module
+moduleImports :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.ImportDecl]
+moduleImports x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Module"),
+        Core.projectionFieldName = (Core.Name "imports")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the package field of hydra.go.syntax.Module
+modulePackage :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm Syntax.PackageClause
+modulePackage x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Module"),
+        Core.projectionFieldName = (Core.Name "package")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the declarations field of hydra.go.syntax.Module
+moduleWithDeclarations :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.TopLevelDecl] -> Typed.TypedTerm Syntax.Module
+moduleWithDeclarations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Module"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Module"),
+              Core.projectionFieldName = (Core.Name "package")})),
+            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.go.syntax.Module"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the imports field of hydra.go.syntax.Module
+moduleWithImports :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.ImportDecl] -> Typed.TypedTerm Syntax.Module
+moduleWithImports original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Module"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Module"),
+              Core.projectionFieldName = (Core.Name "package")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Module"),
+              Core.projectionFieldName = (Core.Name "declarations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the package field of hydra.go.syntax.Module
+moduleWithPackage :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm Syntax.PackageClause -> Typed.TypedTerm Syntax.Module
+moduleWithPackage original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Module"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          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.go.syntax.Module"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Module"),
+              Core.projectionFieldName = (Core.Name "declarations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the bitClear variant of hydra.go.syntax.MulOp
+mulOpBitClear :: Typed.TypedTerm Syntax.MulOp
+mulOpBitClear =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.MulOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bitClear"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the bitwiseAnd variant of hydra.go.syntax.MulOp
+mulOpBitwiseAnd :: Typed.TypedTerm Syntax.MulOp
+mulOpBitwiseAnd =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.MulOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bitwiseAnd"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the divide variant of hydra.go.syntax.MulOp
+mulOpDivide :: Typed.TypedTerm Syntax.MulOp
+mulOpDivide =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.MulOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "divide"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the leftShift variant of hydra.go.syntax.MulOp
+mulOpLeftShift :: Typed.TypedTerm Syntax.MulOp
+mulOpLeftShift =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.MulOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "leftShift"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the multiply variant of hydra.go.syntax.MulOp
+mulOpMultiply :: Typed.TypedTerm Syntax.MulOp
+mulOpMultiply =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.MulOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "multiply"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the remainder variant of hydra.go.syntax.MulOp
+mulOpRemainder :: Typed.TypedTerm Syntax.MulOp
+mulOpRemainder =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.MulOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "remainder"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the rightShift variant of hydra.go.syntax.MulOp
+mulOpRightShift :: Typed.TypedTerm Syntax.MulOp
+mulOpRightShift =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.MulOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "rightShift"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.go.syntax.NamedField
+namedField :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.Tag) -> Typed.TypedTerm Syntax.NamedField
+namedField names type_ tag =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm names)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tag"),
+          Core.fieldTerm = (Typed.unTypedTerm tag)}]}))
+
+-- | DSL accessor for the names field of hydra.go.syntax.NamedField
+namedFieldNames :: Typed.TypedTerm Syntax.NamedField -> Typed.TypedTerm [Syntax.Identifier]
+namedFieldNames x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+        Core.projectionFieldName = (Core.Name "names")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tag field of hydra.go.syntax.NamedField
+namedFieldTag :: Typed.TypedTerm Syntax.NamedField -> Typed.TypedTerm (Maybe Syntax.Tag)
+namedFieldTag x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+        Core.projectionFieldName = (Core.Name "tag")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.NamedField
+namedFieldType :: Typed.TypedTerm Syntax.NamedField -> Typed.TypedTerm Syntax.Type
+namedFieldType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the names field of hydra.go.syntax.NamedField
+namedFieldWithNames :: Typed.TypedTerm Syntax.NamedField -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.NamedField
+namedFieldWithNames original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          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.go.syntax.NamedField"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tag"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+              Core.projectionFieldName = (Core.Name "tag")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tag field of hydra.go.syntax.NamedField
+namedFieldWithTag :: Typed.TypedTerm Syntax.NamedField -> Typed.TypedTerm (Maybe Syntax.Tag) -> Typed.TypedTerm Syntax.NamedField
+namedFieldWithTag original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tag"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.NamedField
+namedFieldWithType :: Typed.TypedTerm Syntax.NamedField -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.NamedField
+namedFieldWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tag"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.NamedField"),
+              Core.projectionFieldName = (Core.Name "tag")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the literal variant of hydra.go.syntax.Operand
+operandLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Operand
+operandLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Operand"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the name variant of hydra.go.syntax.Operand
+operandName :: Typed.TypedTerm Syntax.OperandName -> Typed.TypedTerm Syntax.Operand
+operandName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Operand"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.OperandName
+operandName2 :: Typed.TypedTerm Syntax.QualifiedIdent -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.OperandName
+operandName2 name typeArgs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.OperandName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArgs"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArgs)}]}))
+
+-- | DSL accessor for the name field of hydra.go.syntax.OperandName
+operandNameName :: Typed.TypedTerm Syntax.OperandName -> Typed.TypedTerm Syntax.QualifiedIdent
+operandNameName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.OperandName"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArgs field of hydra.go.syntax.OperandName
+operandNameTypeArgs :: Typed.TypedTerm Syntax.OperandName -> Typed.TypedTerm [Syntax.Type]
+operandNameTypeArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.OperandName"),
+        Core.projectionFieldName = (Core.Name "typeArgs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.go.syntax.OperandName
+operandNameWithName :: Typed.TypedTerm Syntax.OperandName -> Typed.TypedTerm Syntax.QualifiedIdent -> Typed.TypedTerm Syntax.OperandName
+operandNameWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.OperandName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArgs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.OperandName"),
+              Core.projectionFieldName = (Core.Name "typeArgs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArgs field of hydra.go.syntax.OperandName
+operandNameWithTypeArgs :: Typed.TypedTerm Syntax.OperandName -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.OperandName
+operandNameWithTypeArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.OperandName"),
+      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.go.syntax.OperandName"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArgs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the paren variant of hydra.go.syntax.Operand
+operandParen :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Operand
+operandParen x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Operand"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "paren"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.PackageClause wrapper
+packageClause :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.PackageClause
+packageClause x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.PackageClause"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.ParameterDecl
+parameterDecl :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ParameterDecl
+parameterDecl names variadic type_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm names)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variadic"),
+          Core.fieldTerm = (Typed.unTypedTerm variadic)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))
+
+-- | DSL accessor for the names field of hydra.go.syntax.ParameterDecl
+parameterDeclNames :: Typed.TypedTerm Syntax.ParameterDecl -> Typed.TypedTerm [Syntax.Identifier]
+parameterDeclNames x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+        Core.projectionFieldName = (Core.Name "names")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.ParameterDecl
+parameterDeclType :: Typed.TypedTerm Syntax.ParameterDecl -> Typed.TypedTerm Syntax.Type
+parameterDeclType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the variadic field of hydra.go.syntax.ParameterDecl
+parameterDeclVariadic :: Typed.TypedTerm Syntax.ParameterDecl -> Typed.TypedTerm Bool
+parameterDeclVariadic x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+        Core.projectionFieldName = (Core.Name "variadic")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the names field of hydra.go.syntax.ParameterDecl
+parameterDeclWithNames :: Typed.TypedTerm Syntax.ParameterDecl -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.ParameterDecl
+parameterDeclWithNames original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variadic"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+              Core.projectionFieldName = (Core.Name "variadic")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.ParameterDecl
+parameterDeclWithType :: Typed.TypedTerm Syntax.ParameterDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ParameterDecl
+parameterDeclWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variadic"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+              Core.projectionFieldName = (Core.Name "variadic")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the variadic field of hydra.go.syntax.ParameterDecl
+parameterDeclWithVariadic :: Typed.TypedTerm Syntax.ParameterDecl -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ParameterDecl
+parameterDeclWithVariadic original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ParameterDecl"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variadic"),
+          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.go.syntax.ParameterDecl"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.go.syntax.Parameters wrapper
+parameters :: Typed.TypedTerm [Syntax.ParameterDecl] -> Typed.TypedTerm Syntax.Parameters
+parameters x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.Parameters"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.PointerType wrapper
+pointerType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.PointerType
+pointerType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.PointerType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the call variant of hydra.go.syntax.PrimaryExpr
+primaryExprCall :: Typed.TypedTerm Syntax.CallExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+primaryExprCall x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.PrimaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "call"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the conversion variant of hydra.go.syntax.PrimaryExpr
+primaryExprConversion :: Typed.TypedTerm Syntax.Conversion -> Typed.TypedTerm Syntax.PrimaryExpr
+primaryExprConversion x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.PrimaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "conversion"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the index variant of hydra.go.syntax.PrimaryExpr
+primaryExprIndex :: Typed.TypedTerm Syntax.IndexExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+primaryExprIndex x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.PrimaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "index"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the methodExpr variant of hydra.go.syntax.PrimaryExpr
+primaryExprMethodExpr :: Typed.TypedTerm Syntax.MethodExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+primaryExprMethodExpr x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.PrimaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "methodExpr"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the operand variant of hydra.go.syntax.PrimaryExpr
+primaryExprOperand :: Typed.TypedTerm Syntax.Operand -> Typed.TypedTerm Syntax.PrimaryExpr
+primaryExprOperand x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.PrimaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "operand"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the selector variant of hydra.go.syntax.PrimaryExpr
+primaryExprSelector :: Typed.TypedTerm Syntax.SelectorExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+primaryExprSelector x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.PrimaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "selector"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the slice variant of hydra.go.syntax.PrimaryExpr
+primaryExprSlice :: Typed.TypedTerm Syntax.SliceExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+primaryExprSlice x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.PrimaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "slice"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the typeAssertion variant of hydra.go.syntax.PrimaryExpr
+primaryExprTypeAssertion :: Typed.TypedTerm Syntax.TypeAssertionExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+primaryExprTypeAssertion x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.PrimaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typeAssertion"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.QualifiedIdent
+qualifiedIdent :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QualifiedIdent
+qualifiedIdent package name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.QualifiedIdent"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Typed.unTypedTerm package)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.go.syntax.QualifiedIdent
+qualifiedIdentName :: Typed.TypedTerm Syntax.QualifiedIdent -> Typed.TypedTerm Syntax.Identifier
+qualifiedIdentName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.QualifiedIdent"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the package field of hydra.go.syntax.QualifiedIdent
+qualifiedIdentPackage :: Typed.TypedTerm Syntax.QualifiedIdent -> Typed.TypedTerm (Maybe Syntax.Identifier)
+qualifiedIdentPackage x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.QualifiedIdent"),
+        Core.projectionFieldName = (Core.Name "package")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.go.syntax.QualifiedIdent
+qualifiedIdentWithName :: Typed.TypedTerm Syntax.QualifiedIdent -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QualifiedIdent
+qualifiedIdentWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.QualifiedIdent"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.QualifiedIdent"),
+              Core.projectionFieldName = (Core.Name "package")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the package field of hydra.go.syntax.QualifiedIdent
+qualifiedIdentWithPackage :: Typed.TypedTerm Syntax.QualifiedIdent -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.QualifiedIdent
+qualifiedIdentWithPackage original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.QualifiedIdent"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          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.go.syntax.QualifiedIdent"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.RangeClause
+rangeClause :: Typed.TypedTerm (Maybe Syntax.RangeVars) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RangeClause
+rangeClause vars expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.RangeClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "vars"),
+          Core.fieldTerm = (Typed.unTypedTerm vars)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.go.syntax.RangeClause
+rangeClauseExpression :: Typed.TypedTerm Syntax.RangeClause -> Typed.TypedTerm Syntax.Expression
+rangeClauseExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.RangeClause"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the vars field of hydra.go.syntax.RangeClause
+rangeClauseVars :: Typed.TypedTerm Syntax.RangeClause -> Typed.TypedTerm (Maybe Syntax.RangeVars)
+rangeClauseVars x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.RangeClause"),
+        Core.projectionFieldName = (Core.Name "vars")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.go.syntax.RangeClause
+rangeClauseWithExpression :: Typed.TypedTerm Syntax.RangeClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RangeClause
+rangeClauseWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.RangeClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "vars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.RangeClause"),
+              Core.projectionFieldName = (Core.Name "vars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the vars field of hydra.go.syntax.RangeClause
+rangeClauseWithVars :: Typed.TypedTerm Syntax.RangeClause -> Typed.TypedTerm (Maybe Syntax.RangeVars) -> Typed.TypedTerm Syntax.RangeClause
+rangeClauseWithVars original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.RangeClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "vars"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.RangeClause"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the assign variant of hydra.go.syntax.RangeVars
+rangeVarsAssign :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.RangeVars
+rangeVarsAssign x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.RangeVars"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "assign"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the declare variant of hydra.go.syntax.RangeVars
+rangeVarsDeclare :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.RangeVars
+rangeVarsDeclare x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.RangeVars"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "declare"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.RawStringLit wrapper
+rawStringLit :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.RawStringLit
+rawStringLit x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.RawStringLit"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.ReceiveCase
+receiveCase :: Typed.TypedTerm (Maybe Syntax.RangeVars) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ReceiveCase
+receiveCase vars expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ReceiveCase"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "vars"),
+          Core.fieldTerm = (Typed.unTypedTerm vars)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.go.syntax.ReceiveCase
+receiveCaseExpression :: Typed.TypedTerm Syntax.ReceiveCase -> Typed.TypedTerm Syntax.Expression
+receiveCaseExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ReceiveCase"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the vars field of hydra.go.syntax.ReceiveCase
+receiveCaseVars :: Typed.TypedTerm Syntax.ReceiveCase -> Typed.TypedTerm (Maybe Syntax.RangeVars)
+receiveCaseVars x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ReceiveCase"),
+        Core.projectionFieldName = (Core.Name "vars")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.go.syntax.ReceiveCase
+receiveCaseWithExpression :: Typed.TypedTerm Syntax.ReceiveCase -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ReceiveCase
+receiveCaseWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ReceiveCase"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "vars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ReceiveCase"),
+              Core.projectionFieldName = (Core.Name "vars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the vars field of hydra.go.syntax.ReceiveCase
+receiveCaseWithVars :: Typed.TypedTerm Syntax.ReceiveCase -> Typed.TypedTerm (Maybe Syntax.RangeVars) -> Typed.TypedTerm Syntax.ReceiveCase
+receiveCaseWithVars original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ReceiveCase"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "vars"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ReceiveCase"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.Receiver
+receiver :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Receiver
+receiver name type_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Receiver"),
+      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.go.syntax.Receiver
+receiverName :: Typed.TypedTerm Syntax.Receiver -> Typed.TypedTerm (Maybe Syntax.Identifier)
+receiverName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Receiver"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.Receiver
+receiverType :: Typed.TypedTerm Syntax.Receiver -> Typed.TypedTerm Syntax.Type
+receiverType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Receiver"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.go.syntax.Receiver
+receiverWithName :: Typed.TypedTerm Syntax.Receiver -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.Receiver
+receiverWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Receiver"),
+      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.go.syntax.Receiver"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.Receiver
+receiverWithType :: Typed.TypedTerm Syntax.Receiver -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Receiver
+receiverWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Receiver"),
+      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.go.syntax.Receiver"),
+              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 equal variant of hydra.go.syntax.RelOp
+relOpEqual :: Typed.TypedTerm Syntax.RelOp
+relOpEqual =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.RelOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "equal"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the greater variant of hydra.go.syntax.RelOp
+relOpGreater :: Typed.TypedTerm Syntax.RelOp
+relOpGreater =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.RelOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "greater"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the greaterEqual variant of hydra.go.syntax.RelOp
+relOpGreaterEqual :: Typed.TypedTerm Syntax.RelOp
+relOpGreaterEqual =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.RelOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "greaterEqual"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the less variant of hydra.go.syntax.RelOp
+relOpLess :: Typed.TypedTerm Syntax.RelOp
+relOpLess =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.RelOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "less"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the lessEqual variant of hydra.go.syntax.RelOp
+relOpLessEqual :: Typed.TypedTerm Syntax.RelOp
+relOpLessEqual =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.RelOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lessEqual"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the notEqual variant of hydra.go.syntax.RelOp
+relOpNotEqual :: Typed.TypedTerm Syntax.RelOp
+relOpNotEqual =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.RelOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "notEqual"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the parameters variant of hydra.go.syntax.Result
+resultParameters :: Typed.TypedTerm Syntax.Parameters -> Typed.TypedTerm Syntax.Result
+resultParameters x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Result"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "parameters"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.go.syntax.Result
+resultType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Result
+resultType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Result"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.ReturnStmt wrapper
+returnStmt :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ReturnStmt
+returnStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.ReturnStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.RuneLit wrapper
+runeLit :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.RuneLit
+runeLit x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.RuneLit"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.SelectStmt wrapper
+selectStmt :: Typed.TypedTerm [Syntax.CommClause] -> Typed.TypedTerm Syntax.SelectStmt
+selectStmt x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.SelectStmt"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.Selector wrapper
+selector :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Selector
+selector x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.Selector"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.SelectorExpr
+selectorExpr :: Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.SelectorExpr
+selectorExpr expr selector =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SelectorExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "selector"),
+          Core.fieldTerm = (Typed.unTypedTerm selector)}]}))
+
+-- | DSL accessor for the expr field of hydra.go.syntax.SelectorExpr
+selectorExprExpr :: Typed.TypedTerm Syntax.SelectorExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+selectorExprExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SelectorExpr"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the selector field of hydra.go.syntax.SelectorExpr
+selectorExprSelector :: Typed.TypedTerm Syntax.SelectorExpr -> Typed.TypedTerm Syntax.Identifier
+selectorExprSelector x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SelectorExpr"),
+        Core.projectionFieldName = (Core.Name "selector")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.go.syntax.SelectorExpr
+selectorExprWithExpr :: Typed.TypedTerm Syntax.SelectorExpr -> Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.SelectorExpr
+selectorExprWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SelectorExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "selector"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SelectorExpr"),
+              Core.projectionFieldName = (Core.Name "selector")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the selector field of hydra.go.syntax.SelectorExpr
+selectorExprWithSelector :: Typed.TypedTerm Syntax.SelectorExpr -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.SelectorExpr
+selectorExprWithSelector original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SelectorExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SelectorExpr"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "selector"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.SendStmt
+sendStmt :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SendStmt
+sendStmt channel value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SendStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "channel"),
+          Core.fieldTerm = (Typed.unTypedTerm channel)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the channel field of hydra.go.syntax.SendStmt
+sendStmtChannel :: Typed.TypedTerm Syntax.SendStmt -> Typed.TypedTerm Syntax.Expression
+sendStmtChannel x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SendStmt"),
+        Core.projectionFieldName = (Core.Name "channel")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.go.syntax.SendStmt
+sendStmtValue :: Typed.TypedTerm Syntax.SendStmt -> Typed.TypedTerm Syntax.Expression
+sendStmtValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SendStmt"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the channel field of hydra.go.syntax.SendStmt
+sendStmtWithChannel :: Typed.TypedTerm Syntax.SendStmt -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SendStmt
+sendStmtWithChannel original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SendStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "channel"),
+          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.go.syntax.SendStmt"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.go.syntax.SendStmt
+sendStmtWithValue :: Typed.TypedTerm Syntax.SendStmt -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SendStmt
+sendStmtWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SendStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "channel"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SendStmt"),
+              Core.projectionFieldName = (Core.Name "channel")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.ShortVarDecl
+shortVarDecl :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ShortVarDecl
+shortVarDecl names values =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ShortVarDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm names)},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Typed.unTypedTerm values)}]}))
+
+-- | DSL accessor for the names field of hydra.go.syntax.ShortVarDecl
+shortVarDeclNames :: Typed.TypedTerm Syntax.ShortVarDecl -> Typed.TypedTerm [Syntax.Identifier]
+shortVarDeclNames x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ShortVarDecl"),
+        Core.projectionFieldName = (Core.Name "names")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the values field of hydra.go.syntax.ShortVarDecl
+shortVarDeclValues :: Typed.TypedTerm Syntax.ShortVarDecl -> Typed.TypedTerm [Syntax.Expression]
+shortVarDeclValues x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.ShortVarDecl"),
+        Core.projectionFieldName = (Core.Name "values")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the names field of hydra.go.syntax.ShortVarDecl
+shortVarDeclWithNames :: Typed.TypedTerm Syntax.ShortVarDecl -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.ShortVarDecl
+shortVarDeclWithNames original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ShortVarDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ShortVarDecl"),
+              Core.projectionFieldName = (Core.Name "values")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the values field of hydra.go.syntax.ShortVarDecl
+shortVarDeclWithValues :: Typed.TypedTerm Syntax.ShortVarDecl -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ShortVarDecl
+shortVarDeclWithValues original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.ShortVarDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.ShortVarDecl"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.Signature
+signature :: Typed.TypedTerm Syntax.Parameters -> Typed.TypedTerm (Maybe Syntax.Result) -> Typed.TypedTerm Syntax.Signature
+signature parameters result =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Signature"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm parameters)},
+        Core.Field {
+          Core.fieldName = (Core.Name "result"),
+          Core.fieldTerm = (Typed.unTypedTerm result)}]}))
+
+-- | DSL accessor for the parameters field of hydra.go.syntax.Signature
+signatureParameters :: Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.Parameters
+signatureParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Signature"),
+        Core.projectionFieldName = (Core.Name "parameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the result field of hydra.go.syntax.Signature
+signatureResult :: Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm (Maybe Syntax.Result)
+signatureResult x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.Signature"),
+        Core.projectionFieldName = (Core.Name "result")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the parameters field of hydra.go.syntax.Signature
+signatureWithParameters :: Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm Syntax.Parameters -> Typed.TypedTerm Syntax.Signature
+signatureWithParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Signature"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "result"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Signature"),
+              Core.projectionFieldName = (Core.Name "result")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the result field of hydra.go.syntax.Signature
+signatureWithResult :: Typed.TypedTerm Syntax.Signature -> Typed.TypedTerm (Maybe Syntax.Result) -> Typed.TypedTerm Syntax.Signature
+signatureWithResult original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.Signature"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.Signature"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "result"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.SimpleSlice
+simpleSlice :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SimpleSlice
+simpleSlice low high =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SimpleSlice"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "low"),
+          Core.fieldTerm = (Typed.unTypedTerm low)},
+        Core.Field {
+          Core.fieldName = (Core.Name "high"),
+          Core.fieldTerm = (Typed.unTypedTerm high)}]}))
+
+-- | DSL accessor for the high field of hydra.go.syntax.SimpleSlice
+simpleSliceHigh :: Typed.TypedTerm Syntax.SimpleSlice -> Typed.TypedTerm (Maybe Syntax.Expression)
+simpleSliceHigh x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SimpleSlice"),
+        Core.projectionFieldName = (Core.Name "high")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the low field of hydra.go.syntax.SimpleSlice
+simpleSliceLow :: Typed.TypedTerm Syntax.SimpleSlice -> Typed.TypedTerm (Maybe Syntax.Expression)
+simpleSliceLow x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SimpleSlice"),
+        Core.projectionFieldName = (Core.Name "low")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the high field of hydra.go.syntax.SimpleSlice
+simpleSliceWithHigh :: Typed.TypedTerm Syntax.SimpleSlice -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SimpleSlice
+simpleSliceWithHigh original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SimpleSlice"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "low"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SimpleSlice"),
+              Core.projectionFieldName = (Core.Name "low")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "high"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the low field of hydra.go.syntax.SimpleSlice
+simpleSliceWithLow :: Typed.TypedTerm Syntax.SimpleSlice -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SimpleSlice
+simpleSliceWithLow original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SimpleSlice"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "low"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "high"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SimpleSlice"),
+              Core.projectionFieldName = (Core.Name "high")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the assignment variant of hydra.go.syntax.SimpleStmt
+simpleStmtAssignment :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.SimpleStmt
+simpleStmtAssignment x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.SimpleStmt"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "assignment"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the empty variant of hydra.go.syntax.SimpleStmt
+simpleStmtEmpty :: Typed.TypedTerm Syntax.EmptyStmt -> Typed.TypedTerm Syntax.SimpleStmt
+simpleStmtEmpty x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.SimpleStmt"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "empty"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the expression variant of hydra.go.syntax.SimpleStmt
+simpleStmtExpression :: Typed.TypedTerm Syntax.ExpressionStmt -> Typed.TypedTerm Syntax.SimpleStmt
+simpleStmtExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.SimpleStmt"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the incDec variant of hydra.go.syntax.SimpleStmt
+simpleStmtIncDec :: Typed.TypedTerm Syntax.IncDecStmt -> Typed.TypedTerm Syntax.SimpleStmt
+simpleStmtIncDec x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.SimpleStmt"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "incDec"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the send variant of hydra.go.syntax.SimpleStmt
+simpleStmtSend :: Typed.TypedTerm Syntax.SendStmt -> Typed.TypedTerm Syntax.SimpleStmt
+simpleStmtSend x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.SimpleStmt"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "send"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the shortVarDecl variant of hydra.go.syntax.SimpleStmt
+simpleStmtShortVarDecl :: Typed.TypedTerm Syntax.ShortVarDecl -> Typed.TypedTerm Syntax.SimpleStmt
+simpleStmtShortVarDecl x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.SimpleStmt"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "shortVarDecl"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.SliceExpr
+sliceExpr :: Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.Slice -> Typed.TypedTerm Syntax.SliceExpr
+sliceExpr expr slice =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SliceExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "slice"),
+          Core.fieldTerm = (Typed.unTypedTerm slice)}]}))
+
+-- | DSL accessor for the expr field of hydra.go.syntax.SliceExpr
+sliceExprExpr :: Typed.TypedTerm Syntax.SliceExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+sliceExprExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SliceExpr"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the slice field of hydra.go.syntax.SliceExpr
+sliceExprSlice :: Typed.TypedTerm Syntax.SliceExpr -> Typed.TypedTerm Syntax.Slice
+sliceExprSlice x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SliceExpr"),
+        Core.projectionFieldName = (Core.Name "slice")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.go.syntax.SliceExpr
+sliceExprWithExpr :: Typed.TypedTerm Syntax.SliceExpr -> Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.SliceExpr
+sliceExprWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SliceExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "slice"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SliceExpr"),
+              Core.projectionFieldName = (Core.Name "slice")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the slice field of hydra.go.syntax.SliceExpr
+sliceExprWithSlice :: Typed.TypedTerm Syntax.SliceExpr -> Typed.TypedTerm Syntax.Slice -> Typed.TypedTerm Syntax.SliceExpr
+sliceExprWithSlice original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SliceExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SliceExpr"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "slice"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the full variant of hydra.go.syntax.Slice
+sliceFull :: Typed.TypedTerm Syntax.FullSlice -> Typed.TypedTerm Syntax.Slice
+sliceFull x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Slice"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "full"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.go.syntax.Slice
+sliceSimple :: Typed.TypedTerm Syntax.SimpleSlice -> Typed.TypedTerm Syntax.Slice
+sliceSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Slice"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.SliceType wrapper
+sliceType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.SliceType
+sliceType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.SliceType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.SourceFile
+sourceFile :: Typed.TypedTerm Syntax.PackageClause -> Typed.TypedTerm [Syntax.ImportDecl] -> Typed.TypedTerm [Syntax.TopLevelDecl] -> Typed.TypedTerm Syntax.SourceFile
+sourceFile package imports declarations =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Typed.unTypedTerm package)},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Typed.unTypedTerm imports)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarations"),
+          Core.fieldTerm = (Typed.unTypedTerm declarations)}]}))
+
+-- | DSL accessor for the declarations field of hydra.go.syntax.SourceFile
+sourceFileDeclarations :: Typed.TypedTerm Syntax.SourceFile -> Typed.TypedTerm [Syntax.TopLevelDecl]
+sourceFileDeclarations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+        Core.projectionFieldName = (Core.Name "declarations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the imports field of hydra.go.syntax.SourceFile
+sourceFileImports :: Typed.TypedTerm Syntax.SourceFile -> Typed.TypedTerm [Syntax.ImportDecl]
+sourceFileImports x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+        Core.projectionFieldName = (Core.Name "imports")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the package field of hydra.go.syntax.SourceFile
+sourceFilePackage :: Typed.TypedTerm Syntax.SourceFile -> Typed.TypedTerm Syntax.PackageClause
+sourceFilePackage x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+        Core.projectionFieldName = (Core.Name "package")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the declarations field of hydra.go.syntax.SourceFile
+sourceFileWithDeclarations :: Typed.TypedTerm Syntax.SourceFile -> Typed.TypedTerm [Syntax.TopLevelDecl] -> Typed.TypedTerm Syntax.SourceFile
+sourceFileWithDeclarations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+              Core.projectionFieldName = (Core.Name "package")})),
+            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.go.syntax.SourceFile"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the imports field of hydra.go.syntax.SourceFile
+sourceFileWithImports :: Typed.TypedTerm Syntax.SourceFile -> Typed.TypedTerm [Syntax.ImportDecl] -> Typed.TypedTerm Syntax.SourceFile
+sourceFileWithImports original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+              Core.projectionFieldName = (Core.Name "package")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+              Core.projectionFieldName = (Core.Name "declarations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the package field of hydra.go.syntax.SourceFile
+sourceFileWithPackage :: Typed.TypedTerm Syntax.SourceFile -> Typed.TypedTerm Syntax.PackageClause -> Typed.TypedTerm Syntax.SourceFile
+sourceFileWithPackage original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          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.go.syntax.SourceFile"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.SourceFile"),
+              Core.projectionFieldName = (Core.Name "declarations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the block variant of hydra.go.syntax.Statement
+statementBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.Statement
+statementBlock x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "block"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the break variant of hydra.go.syntax.Statement
+statementBreak :: Typed.TypedTerm Syntax.BreakStmt -> Typed.TypedTerm Syntax.Statement
+statementBreak x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "break"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the continue variant of hydra.go.syntax.Statement
+statementContinue :: Typed.TypedTerm Syntax.ContinueStmt -> Typed.TypedTerm Syntax.Statement
+statementContinue x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "continue"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the declaration variant of hydra.go.syntax.Statement
+statementDeclaration :: Typed.TypedTerm Syntax.Declaration -> Typed.TypedTerm Syntax.Statement
+statementDeclaration x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "declaration"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the defer variant of hydra.go.syntax.Statement
+statementDefer :: Typed.TypedTerm Syntax.DeferStmt -> Typed.TypedTerm Syntax.Statement
+statementDefer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "defer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the fallthrough variant of hydra.go.syntax.Statement
+statementFallthrough :: Typed.TypedTerm Syntax.FallthroughStmt -> Typed.TypedTerm Syntax.Statement
+statementFallthrough x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "fallthrough"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the for variant of hydra.go.syntax.Statement
+statementFor :: Typed.TypedTerm Syntax.ForStmt -> Typed.TypedTerm Syntax.Statement
+statementFor x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "for"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the go variant of hydra.go.syntax.Statement
+statementGo :: Typed.TypedTerm Syntax.GoStmt -> Typed.TypedTerm Syntax.Statement
+statementGo x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "go"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the goto variant of hydra.go.syntax.Statement
+statementGoto :: Typed.TypedTerm Syntax.GotoStmt -> Typed.TypedTerm Syntax.Statement
+statementGoto x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "goto"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the if variant of hydra.go.syntax.Statement
+statementIf :: Typed.TypedTerm Syntax.IfStmt -> Typed.TypedTerm Syntax.Statement
+statementIf x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "if"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the labeled variant of hydra.go.syntax.Statement
+statementLabeled :: Typed.TypedTerm Syntax.LabeledStmt -> Typed.TypedTerm Syntax.Statement
+statementLabeled x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "labeled"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the return variant of hydra.go.syntax.Statement
+statementReturn :: Typed.TypedTerm Syntax.ReturnStmt -> Typed.TypedTerm Syntax.Statement
+statementReturn x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "return"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the select variant of hydra.go.syntax.Statement
+statementSelect :: Typed.TypedTerm Syntax.SelectStmt -> Typed.TypedTerm Syntax.Statement
+statementSelect x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "select"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.go.syntax.Statement
+statementSimple :: Typed.TypedTerm Syntax.SimpleStmt -> Typed.TypedTerm Syntax.Statement
+statementSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the switch variant of hydra.go.syntax.Statement
+statementSwitch :: Typed.TypedTerm Syntax.SwitchStmt -> Typed.TypedTerm Syntax.Statement
+statementSwitch x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "switch"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interpreted variant of hydra.go.syntax.StringLit
+stringLitInterpreted :: Typed.TypedTerm Syntax.InterpretedStringLit -> Typed.TypedTerm Syntax.StringLit
+stringLitInterpreted x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.StringLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interpreted"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the raw variant of hydra.go.syntax.StringLit
+stringLitRaw :: Typed.TypedTerm Syntax.RawStringLit -> Typed.TypedTerm Syntax.StringLit
+stringLitRaw x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.StringLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "raw"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.StructType wrapper
+structType :: Typed.TypedTerm [Syntax.FieldDecl] -> Typed.TypedTerm Syntax.StructType
+structType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.StructType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the expression variant of hydra.go.syntax.SwitchStmt
+switchStmtExpression :: Typed.TypedTerm Syntax.ExprSwitchStmt -> Typed.TypedTerm Syntax.SwitchStmt
+switchStmtExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.SwitchStmt"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.go.syntax.SwitchStmt
+switchStmtType :: Typed.TypedTerm Syntax.TypeSwitchStmt -> Typed.TypedTerm Syntax.SwitchStmt
+switchStmtType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.SwitchStmt"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.Tag wrapper
+tag :: Typed.TypedTerm Syntax.StringLit -> Typed.TypedTerm Syntax.Tag
+tag x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.Tag"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the declaration variant of hydra.go.syntax.TopLevelDecl
+topLevelDeclDeclaration :: Typed.TypedTerm Syntax.Declaration -> Typed.TypedTerm Syntax.TopLevelDecl
+topLevelDeclDeclaration x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TopLevelDecl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "declaration"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the function variant of hydra.go.syntax.TopLevelDecl
+topLevelDeclFunction :: Typed.TypedTerm Syntax.FunctionDecl -> Typed.TypedTerm Syntax.TopLevelDecl
+topLevelDeclFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TopLevelDecl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "function"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the method variant of hydra.go.syntax.TopLevelDecl
+topLevelDeclMethod :: Typed.TypedTerm Syntax.MethodDecl -> Typed.TypedTerm Syntax.TopLevelDecl
+topLevelDeclMethod x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TopLevelDecl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "method"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.go.syntax.TypeAssertion wrapper
+typeAssertion :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeAssertion
+typeAssertion x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.TypeAssertion"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.TypeAssertionExpr
+typeAssertionExpr :: Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeAssertionExpr
+typeAssertionExpr expr type_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeAssertionExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))
+
+-- | DSL accessor for the expr field of hydra.go.syntax.TypeAssertionExpr
+typeAssertionExprExpr :: Typed.TypedTerm Syntax.TypeAssertionExpr -> Typed.TypedTerm Syntax.PrimaryExpr
+typeAssertionExprExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeAssertionExpr"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.TypeAssertionExpr
+typeAssertionExprType :: Typed.TypedTerm Syntax.TypeAssertionExpr -> Typed.TypedTerm Syntax.Type
+typeAssertionExprType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeAssertionExpr"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.go.syntax.TypeAssertionExpr
+typeAssertionExprWithExpr :: Typed.TypedTerm Syntax.TypeAssertionExpr -> Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.TypeAssertionExpr
+typeAssertionExprWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeAssertionExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          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.go.syntax.TypeAssertionExpr"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.TypeAssertionExpr
+typeAssertionExprWithType :: Typed.TypedTerm Syntax.TypeAssertionExpr -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeAssertionExpr
+typeAssertionExprWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeAssertionExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeAssertionExpr"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.TypeCaseClause
+typeCaseClause :: Typed.TypedTerm (Maybe [Syntax.Type]) -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.TypeCaseClause
+typeCaseClause case_ statements =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeCaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Typed.unTypedTerm case_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm statements)}]}))
+
+-- | DSL accessor for the case field of hydra.go.syntax.TypeCaseClause
+typeCaseClauseCase :: Typed.TypedTerm Syntax.TypeCaseClause -> Typed.TypedTerm (Maybe [Syntax.Type])
+typeCaseClauseCase x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeCaseClause"),
+        Core.projectionFieldName = (Core.Name "case")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the statements field of hydra.go.syntax.TypeCaseClause
+typeCaseClauseStatements :: Typed.TypedTerm Syntax.TypeCaseClause -> Typed.TypedTerm [Syntax.Statement]
+typeCaseClauseStatements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeCaseClause"),
+        Core.projectionFieldName = (Core.Name "statements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the case field of hydra.go.syntax.TypeCaseClause
+typeCaseClauseWithCase :: Typed.TypedTerm Syntax.TypeCaseClause -> Typed.TypedTerm (Maybe [Syntax.Type]) -> Typed.TypedTerm Syntax.TypeCaseClause
+typeCaseClauseWithCase original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeCaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeCaseClause"),
+              Core.projectionFieldName = (Core.Name "statements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statements field of hydra.go.syntax.TypeCaseClause
+typeCaseClauseWithStatements :: Typed.TypedTerm Syntax.TypeCaseClause -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.TypeCaseClause
+typeCaseClauseWithStatements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeCaseClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "case"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeCaseClause"),
+              Core.projectionFieldName = (Core.Name "case")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.go.syntax.TypeConstraint wrapper
+typeConstraint :: Typed.TypedTerm Syntax.TypeElem -> Typed.TypedTerm Syntax.TypeConstraint
+typeConstraint x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.TypeConstraint"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.go.syntax.TypeDecl wrapper
+typeDecl :: Typed.TypedTerm [Syntax.TypeSpec] -> Typed.TypedTerm Syntax.TypeDecl
+typeDecl x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.TypeDecl"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.TypeDef
+typeDef :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeParameters) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeDef
+typeDef name typeParams type_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          Core.fieldTerm = (Typed.unTypedTerm typeParams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))
+
+-- | DSL accessor for the name field of hydra.go.syntax.TypeDef
+typeDefName :: Typed.TypedTerm Syntax.TypeDef -> Typed.TypedTerm Syntax.Identifier
+typeDefName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.TypeDef
+typeDefType :: Typed.TypedTerm Syntax.TypeDef -> Typed.TypedTerm Syntax.Type
+typeDefType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeParams field of hydra.go.syntax.TypeDef
+typeDefTypeParams :: Typed.TypedTerm Syntax.TypeDef -> Typed.TypedTerm (Maybe Syntax.TypeParameters)
+typeDefTypeParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+        Core.projectionFieldName = (Core.Name "typeParams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.go.syntax.TypeDef
+typeDefWithName :: Typed.TypedTerm Syntax.TypeDef -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.TypeDef
+typeDefWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+              Core.projectionFieldName = (Core.Name "typeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.TypeDef
+typeDefWithType :: Typed.TypedTerm Syntax.TypeDef -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeDef
+typeDefWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+      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.go.syntax.TypeDef"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+              Core.projectionFieldName = (Core.Name "typeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the typeParams field of hydra.go.syntax.TypeDef
+typeDefWithTypeParams :: Typed.TypedTerm Syntax.TypeDef -> Typed.TypedTerm (Maybe Syntax.TypeParameters) -> Typed.TypedTerm Syntax.TypeDef
+typeDefWithTypeParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeDef"),
+      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.go.syntax.TypeDef"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeParams"),
+          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.go.syntax.TypeDef"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.go.syntax.TypeElem wrapper
+typeElem :: Typed.TypedTerm [Syntax.TypeTerm] -> Typed.TypedTerm Syntax.TypeElem
+typeElem x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.TypeElem"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the array variant of hydra.go.syntax.TypeLit
+typeLitArray :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.TypeLit
+typeLitArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "array"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the channel variant of hydra.go.syntax.TypeLit
+typeLitChannel :: Typed.TypedTerm Syntax.ChannelType -> Typed.TypedTerm Syntax.TypeLit
+typeLitChannel x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "channel"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the function variant of hydra.go.syntax.TypeLit
+typeLitFunction :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.TypeLit
+typeLitFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "function"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interface variant of hydra.go.syntax.TypeLit
+typeLitInterface :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.TypeLit
+typeLitInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the map variant of hydra.go.syntax.TypeLit
+typeLitMap :: Typed.TypedTerm Syntax.MapType -> Typed.TypedTerm Syntax.TypeLit
+typeLitMap x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "map"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the pointer variant of hydra.go.syntax.TypeLit
+typeLitPointer :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.TypeLit
+typeLitPointer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "pointer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the slice variant of hydra.go.syntax.TypeLit
+typeLitSlice :: Typed.TypedTerm Syntax.SliceType -> Typed.TypedTerm Syntax.TypeLit
+typeLitSlice x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "slice"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the struct variant of hydra.go.syntax.TypeLit
+typeLitStruct :: Typed.TypedTerm Syntax.StructType -> Typed.TypedTerm Syntax.TypeLit
+typeLitStruct x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeLit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "struct"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the literal variant of hydra.go.syntax.Type
+typeLiteral :: Typed.TypedTerm Syntax.TypeLit -> Typed.TypedTerm Syntax.Type
+typeLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the name variant of hydra.go.syntax.Type
+typeName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.Type
+typeName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.TypeName
+typeName2 :: Typed.TypedTerm Syntax.QualifiedIdent -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.TypeName
+typeName2 name typeArgs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArgs"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArgs)}]}))
+
+-- | DSL accessor for the name field of hydra.go.syntax.TypeName
+typeNameName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.QualifiedIdent
+typeNameName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeName"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArgs field of hydra.go.syntax.TypeName
+typeNameTypeArgs :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm [Syntax.Type]
+typeNameTypeArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeName"),
+        Core.projectionFieldName = (Core.Name "typeArgs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.go.syntax.TypeName
+typeNameWithName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.QualifiedIdent -> Typed.TypedTerm Syntax.TypeName
+typeNameWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArgs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeName"),
+              Core.projectionFieldName = (Core.Name "typeArgs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArgs field of hydra.go.syntax.TypeName
+typeNameWithTypeArgs :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.TypeName
+typeNameWithTypeArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeName"),
+      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.go.syntax.TypeName"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArgs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.go.syntax.TypeParamDecl
+typeParamDecl :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.TypeConstraint -> Typed.TypedTerm Syntax.TypeParamDecl
+typeParamDecl names constraint =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeParamDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm names)},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraint"),
+          Core.fieldTerm = (Typed.unTypedTerm constraint)}]}))
+
+-- | DSL accessor for the constraint field of hydra.go.syntax.TypeParamDecl
+typeParamDeclConstraint :: Typed.TypedTerm Syntax.TypeParamDecl -> Typed.TypedTerm Syntax.TypeConstraint
+typeParamDeclConstraint x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeParamDecl"),
+        Core.projectionFieldName = (Core.Name "constraint")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the names field of hydra.go.syntax.TypeParamDecl
+typeParamDeclNames :: Typed.TypedTerm Syntax.TypeParamDecl -> Typed.TypedTerm [Syntax.Identifier]
+typeParamDeclNames x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeParamDecl"),
+        Core.projectionFieldName = (Core.Name "names")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the constraint field of hydra.go.syntax.TypeParamDecl
+typeParamDeclWithConstraint :: Typed.TypedTerm Syntax.TypeParamDecl -> Typed.TypedTerm Syntax.TypeConstraint -> Typed.TypedTerm Syntax.TypeParamDecl
+typeParamDeclWithConstraint original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeParamDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeParamDecl"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraint"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the names field of hydra.go.syntax.TypeParamDecl
+typeParamDeclWithNames :: Typed.TypedTerm Syntax.TypeParamDecl -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.TypeParamDecl
+typeParamDeclWithNames original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeParamDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "constraint"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeParamDecl"),
+              Core.projectionFieldName = (Core.Name "constraint")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.go.syntax.TypeParameters wrapper
+typeParameters :: Typed.TypedTerm [Syntax.TypeParamDecl] -> Typed.TypedTerm Syntax.TypeParameters
+typeParameters x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.TypeParameters"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the paren variant of hydra.go.syntax.Type
+typeParen :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type
+typeParen x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "paren"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the alias variant of hydra.go.syntax.TypeSpec
+typeSpecAlias :: Typed.TypedTerm Syntax.AliasDecl -> Typed.TypedTerm Syntax.TypeSpec
+typeSpecAlias x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeSpec"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "alias"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the definition variant of hydra.go.syntax.TypeSpec
+typeSpecDefinition :: Typed.TypedTerm Syntax.TypeDef -> Typed.TypedTerm Syntax.TypeSpec
+typeSpecDefinition x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.TypeSpec"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "definition"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.go.syntax.TypeSwitchGuard
+typeSwitchGuard :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.TypeSwitchGuard
+typeSwitchGuard name expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeSwitchGuard"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.go.syntax.TypeSwitchGuard
+typeSwitchGuardExpression :: Typed.TypedTerm Syntax.TypeSwitchGuard -> Typed.TypedTerm Syntax.PrimaryExpr
+typeSwitchGuardExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchGuard"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.go.syntax.TypeSwitchGuard
+typeSwitchGuardName :: Typed.TypedTerm Syntax.TypeSwitchGuard -> Typed.TypedTerm (Maybe Syntax.Identifier)
+typeSwitchGuardName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchGuard"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.go.syntax.TypeSwitchGuard
+typeSwitchGuardWithExpression :: Typed.TypedTerm Syntax.TypeSwitchGuard -> Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.TypeSwitchGuard
+typeSwitchGuardWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeSwitchGuard"),
+      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.go.syntax.TypeSwitchGuard"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.go.syntax.TypeSwitchGuard
+typeSwitchGuardWithName :: Typed.TypedTerm Syntax.TypeSwitchGuard -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.TypeSwitchGuard
+typeSwitchGuardWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeSwitchGuard"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchGuard"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.TypeSwitchStmt
+typeSwitchStmt :: Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm Syntax.TypeSwitchGuard -> Typed.TypedTerm [Syntax.TypeCaseClause] -> Typed.TypedTerm Syntax.TypeSwitchStmt
+typeSwitchStmt init guard cases =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm init)},
+        Core.Field {
+          Core.fieldName = (Core.Name "guard"),
+          Core.fieldTerm = (Typed.unTypedTerm guard)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))
+
+-- | DSL accessor for the cases field of hydra.go.syntax.TypeSwitchStmt
+typeSwitchStmtCases :: Typed.TypedTerm Syntax.TypeSwitchStmt -> Typed.TypedTerm [Syntax.TypeCaseClause]
+typeSwitchStmtCases x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+        Core.projectionFieldName = (Core.Name "cases")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the guard field of hydra.go.syntax.TypeSwitchStmt
+typeSwitchStmtGuard :: Typed.TypedTerm Syntax.TypeSwitchStmt -> Typed.TypedTerm Syntax.TypeSwitchGuard
+typeSwitchStmtGuard x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+        Core.projectionFieldName = (Core.Name "guard")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the init field of hydra.go.syntax.TypeSwitchStmt
+typeSwitchStmtInit :: Typed.TypedTerm Syntax.TypeSwitchStmt -> Typed.TypedTerm (Maybe Syntax.SimpleStmt)
+typeSwitchStmtInit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+        Core.projectionFieldName = (Core.Name "init")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cases field of hydra.go.syntax.TypeSwitchStmt
+typeSwitchStmtWithCases :: Typed.TypedTerm Syntax.TypeSwitchStmt -> Typed.TypedTerm [Syntax.TypeCaseClause] -> Typed.TypedTerm Syntax.TypeSwitchStmt
+typeSwitchStmtWithCases original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "guard"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "guard")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the guard field of hydra.go.syntax.TypeSwitchStmt
+typeSwitchStmtWithGuard :: Typed.TypedTerm Syntax.TypeSwitchStmt -> Typed.TypedTerm Syntax.TypeSwitchGuard -> Typed.TypedTerm Syntax.TypeSwitchStmt
+typeSwitchStmtWithGuard original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "guard"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "cases")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the init field of hydra.go.syntax.TypeSwitchStmt
+typeSwitchStmtWithInit :: Typed.TypedTerm Syntax.TypeSwitchStmt -> Typed.TypedTerm (Maybe Syntax.SimpleStmt) -> Typed.TypedTerm Syntax.TypeSwitchStmt
+typeSwitchStmtWithInit original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "guard"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "guard")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeSwitchStmt"),
+              Core.projectionFieldName = (Core.Name "cases")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.go.syntax.TypeTerm
+typeTerm :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeTerm
+typeTerm underlying type_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeTerm"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "underlying"),
+          Core.fieldTerm = (Typed.unTypedTerm underlying)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.TypeTerm
+typeTermType :: Typed.TypedTerm Syntax.TypeTerm -> Typed.TypedTerm Syntax.Type
+typeTermType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeTerm"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the underlying field of hydra.go.syntax.TypeTerm
+typeTermUnderlying :: Typed.TypedTerm Syntax.TypeTerm -> Typed.TypedTerm Bool
+typeTermUnderlying x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeTerm"),
+        Core.projectionFieldName = (Core.Name "underlying")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the type field of hydra.go.syntax.TypeTerm
+typeTermWithType :: Typed.TypedTerm Syntax.TypeTerm -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeTerm
+typeTermWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeTerm"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "underlying"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.TypeTerm"),
+              Core.projectionFieldName = (Core.Name "underlying")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the underlying field of hydra.go.syntax.TypeTerm
+typeTermWithUnderlying :: Typed.TypedTerm Syntax.TypeTerm -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypeTerm
+typeTermWithUnderlying original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.TypeTerm"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "underlying"),
+          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.go.syntax.TypeTerm"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL accessor for the body of hydra.go.syntax.Block
+unBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm [Syntax.Statement]
+unBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.Block")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.BreakStmt
+unBreakStmt :: Typed.TypedTerm Syntax.BreakStmt -> Typed.TypedTerm (Maybe Syntax.Identifier)
+unBreakStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.BreakStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.ConstDecl
+unConstDecl :: Typed.TypedTerm Syntax.ConstDecl -> Typed.TypedTerm [Syntax.ConstSpec]
+unConstDecl x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.ConstDecl")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.ContinueStmt
+unContinueStmt :: Typed.TypedTerm Syntax.ContinueStmt -> Typed.TypedTerm (Maybe Syntax.Identifier)
+unContinueStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.ContinueStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.DeferStmt
+unDeferStmt :: Typed.TypedTerm Syntax.DeferStmt -> Typed.TypedTerm Syntax.Expression
+unDeferStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.DeferStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.ElementList
+unElementList :: Typed.TypedTerm Syntax.ElementList -> Typed.TypedTerm [Syntax.KeyedElement]
+unElementList x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.ElementList")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.EmptyStmt
+unEmptyStmt :: Typed.TypedTerm Syntax.EmptyStmt -> Typed.TypedTerm ()
+unEmptyStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.EmptyStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.ExpressionStmt
+unExpressionStmt :: Typed.TypedTerm Syntax.ExpressionStmt -> Typed.TypedTerm Syntax.Expression
+unExpressionStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.ExpressionStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.FallthroughStmt
+unFallthroughStmt :: Typed.TypedTerm Syntax.FallthroughStmt -> Typed.TypedTerm ()
+unFallthroughStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.FallthroughStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.FloatLit
+unFloatLit :: Typed.TypedTerm Syntax.FloatLit -> Typed.TypedTerm Double
+unFloatLit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.FloatLit")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.FunctionBody
+unFunctionBody :: Typed.TypedTerm Syntax.FunctionBody -> Typed.TypedTerm Syntax.Block
+unFunctionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.FunctionBody")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.FunctionType
+unFunctionType :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Signature
+unFunctionType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.FunctionType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.GoStmt
+unGoStmt :: Typed.TypedTerm Syntax.GoStmt -> Typed.TypedTerm Syntax.Expression
+unGoStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.GoStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.GotoStmt
+unGotoStmt :: Typed.TypedTerm Syntax.GotoStmt -> Typed.TypedTerm Syntax.Identifier
+unGotoStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.GotoStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.Identifier
+unIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm String
+unIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.Identifier")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.ImaginaryLit
+unImaginaryLit :: Typed.TypedTerm Syntax.ImaginaryLit -> Typed.TypedTerm Double
+unImaginaryLit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.ImaginaryLit")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.ImportDecl
+unImportDecl :: Typed.TypedTerm Syntax.ImportDecl -> Typed.TypedTerm [Syntax.ImportSpec]
+unImportDecl x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.ImportDecl")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.ImportPath
+unImportPath :: Typed.TypedTerm Syntax.ImportPath -> Typed.TypedTerm Syntax.StringLit
+unImportPath x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.ImportPath")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.Index
+unIndex :: Typed.TypedTerm Syntax.Index -> Typed.TypedTerm [Syntax.Expression]
+unIndex x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.Index")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.IntLit
+unIntLit :: Typed.TypedTerm Syntax.IntLit -> Typed.TypedTerm Integer
+unIntLit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.IntLit")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.InterfaceType
+unInterfaceType :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm [Syntax.InterfaceElem]
+unInterfaceType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.InterfaceType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.InterpretedStringLit
+unInterpretedStringLit :: Typed.TypedTerm Syntax.InterpretedStringLit -> Typed.TypedTerm String
+unInterpretedStringLit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.InterpretedStringLit")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.LiteralValue
+unLiteralValue :: Typed.TypedTerm Syntax.LiteralValue -> Typed.TypedTerm [Syntax.KeyedElement]
+unLiteralValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.LiteralValue")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.PackageClause
+unPackageClause :: Typed.TypedTerm Syntax.PackageClause -> Typed.TypedTerm Syntax.Identifier
+unPackageClause x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.PackageClause")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.Parameters
+unParameters :: Typed.TypedTerm Syntax.Parameters -> Typed.TypedTerm [Syntax.ParameterDecl]
+unParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.Parameters")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.PointerType
+unPointerType :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.Type
+unPointerType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.PointerType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.RawStringLit
+unRawStringLit :: Typed.TypedTerm Syntax.RawStringLit -> Typed.TypedTerm String
+unRawStringLit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.RawStringLit")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.ReturnStmt
+unReturnStmt :: Typed.TypedTerm Syntax.ReturnStmt -> Typed.TypedTerm [Syntax.Expression]
+unReturnStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.ReturnStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.RuneLit
+unRuneLit :: Typed.TypedTerm Syntax.RuneLit -> Typed.TypedTerm Int
+unRuneLit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.RuneLit")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.SelectStmt
+unSelectStmt :: Typed.TypedTerm Syntax.SelectStmt -> Typed.TypedTerm [Syntax.CommClause]
+unSelectStmt x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.SelectStmt")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.Selector
+unSelector :: Typed.TypedTerm Syntax.Selector -> Typed.TypedTerm Syntax.Identifier
+unSelector x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.Selector")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.SliceType
+unSliceType :: Typed.TypedTerm Syntax.SliceType -> Typed.TypedTerm Syntax.Type
+unSliceType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.SliceType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.StructType
+unStructType :: Typed.TypedTerm Syntax.StructType -> Typed.TypedTerm [Syntax.FieldDecl]
+unStructType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.StructType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.Tag
+unTag :: Typed.TypedTerm Syntax.Tag -> Typed.TypedTerm Syntax.StringLit
+unTag x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.Tag")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.TypeAssertion
+unTypeAssertion :: Typed.TypedTerm Syntax.TypeAssertion -> Typed.TypedTerm Syntax.Type
+unTypeAssertion x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.TypeAssertion")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.TypeConstraint
+unTypeConstraint :: Typed.TypedTerm Syntax.TypeConstraint -> Typed.TypedTerm Syntax.TypeElem
+unTypeConstraint x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.TypeConstraint")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.TypeDecl
+unTypeDecl :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.TypeSpec]
+unTypeDecl x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.TypeDecl")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.TypeElem
+unTypeElem :: Typed.TypedTerm Syntax.TypeElem -> Typed.TypedTerm [Syntax.TypeTerm]
+unTypeElem x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.TypeElem")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.TypeParameters
+unTypeParameters :: Typed.TypedTerm Syntax.TypeParameters -> Typed.TypedTerm [Syntax.TypeParamDecl]
+unTypeParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.TypeParameters")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.go.syntax.VarDecl
+unVarDecl :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.VarSpec]
+unVarDecl x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.go.syntax.VarDecl")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the op variant of hydra.go.syntax.UnaryExpr
+unaryExprOp :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryExpr
+unaryExprOp x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "op"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primary variant of hydra.go.syntax.UnaryExpr
+unaryExprPrimary :: Typed.TypedTerm Syntax.PrimaryExpr -> Typed.TypedTerm Syntax.UnaryExpr
+unaryExprPrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryExpr"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the addressOf variant of hydra.go.syntax.UnaryOp
+unaryOpAddressOf :: Typed.TypedTerm Syntax.UnaryOp
+unaryOpAddressOf =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "addressOf"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the deref variant of hydra.go.syntax.UnaryOp
+unaryOpDeref :: Typed.TypedTerm Syntax.UnaryOp
+unaryOpDeref =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "deref"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the minus variant of hydra.go.syntax.UnaryOp
+unaryOpMinus :: Typed.TypedTerm Syntax.UnaryOp
+unaryOpMinus =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "minus"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the not variant of hydra.go.syntax.UnaryOp
+unaryOpNot :: Typed.TypedTerm Syntax.UnaryOp
+unaryOpNot =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "not"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the plus variant of hydra.go.syntax.UnaryOp
+unaryOpPlus :: Typed.TypedTerm Syntax.UnaryOp
+unaryOpPlus =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "plus"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the receive variant of hydra.go.syntax.UnaryOp
+unaryOpReceive :: Typed.TypedTerm Syntax.UnaryOp
+unaryOpReceive =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "receive"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the xor variant of hydra.go.syntax.UnaryOp
+unaryOpXor :: Typed.TypedTerm Syntax.UnaryOp
+unaryOpXor =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.go.syntax.UnaryOp"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "xor"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.go.syntax.UnaryOperation
+unaryOperation :: Typed.TypedTerm Syntax.UnaryOp -> Typed.TypedTerm Syntax.UnaryExpr -> Typed.TypedTerm Syntax.UnaryOperation
+unaryOperation op operand =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.UnaryOperation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm op)},
+        Core.Field {
+          Core.fieldName = (Core.Name "operand"),
+          Core.fieldTerm = (Typed.unTypedTerm operand)}]}))
+
+-- | DSL accessor for the op field of hydra.go.syntax.UnaryOperation
+unaryOperationOp :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryOp
+unaryOperationOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.UnaryOperation"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the operand field of hydra.go.syntax.UnaryOperation
+unaryOperationOperand :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryExpr
+unaryOperationOperand x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.UnaryOperation"),
+        Core.projectionFieldName = (Core.Name "operand")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the op field of hydra.go.syntax.UnaryOperation
+unaryOperationWithOp :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryOp -> Typed.TypedTerm Syntax.UnaryOperation
+unaryOperationWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.UnaryOperation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "operand"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.UnaryOperation"),
+              Core.projectionFieldName = (Core.Name "operand")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the operand field of hydra.go.syntax.UnaryOperation
+unaryOperationWithOperand :: Typed.TypedTerm Syntax.UnaryOperation -> Typed.TypedTerm Syntax.UnaryExpr -> Typed.TypedTerm Syntax.UnaryOperation
+unaryOperationWithOperand original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.UnaryOperation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.UnaryOperation"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "operand"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.go.syntax.VarDecl wrapper
+varDecl :: Typed.TypedTerm [Syntax.VarSpec] -> Typed.TypedTerm Syntax.VarDecl
+varDecl x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.go.syntax.VarDecl"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.go.syntax.VarSpec
+varSpec :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.VarSpec
+varSpec names type_ values =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Typed.unTypedTerm names)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Typed.unTypedTerm values)}]}))
+
+-- | DSL accessor for the names field of hydra.go.syntax.VarSpec
+varSpecNames :: Typed.TypedTerm Syntax.VarSpec -> Typed.TypedTerm [Syntax.Identifier]
+varSpecNames x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+        Core.projectionFieldName = (Core.Name "names")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.go.syntax.VarSpec
+varSpecType :: Typed.TypedTerm Syntax.VarSpec -> Typed.TypedTerm (Maybe Syntax.Type)
+varSpecType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the values field of hydra.go.syntax.VarSpec
+varSpecValues :: Typed.TypedTerm Syntax.VarSpec -> Typed.TypedTerm [Syntax.Expression]
+varSpecValues x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+        Core.projectionFieldName = (Core.Name "values")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the names field of hydra.go.syntax.VarSpec
+varSpecWithNames :: Typed.TypedTerm Syntax.VarSpec -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.VarSpec
+varSpecWithNames original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          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.go.syntax.VarSpec"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+              Core.projectionFieldName = (Core.Name "values")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.go.syntax.VarSpec
+varSpecWithType :: Typed.TypedTerm Syntax.VarSpec -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.VarSpec
+varSpecWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+              Core.projectionFieldName = (Core.Name "values")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the values field of hydra.go.syntax.VarSpec
+varSpecWithValues :: Typed.TypedTerm Syntax.VarSpec -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.VarSpec
+varSpecWithValues original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "names"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+              Core.projectionFieldName = (Core.Name "names")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.go.syntax.VarSpec"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "values"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
diff --git a/src/main/haskell/Hydra/Go/Language.hs b/src/main/haskell/Hydra/Go/Language.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Go/Language.hs
@@ -0,0 +1,228 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Language constraints and reserved words for Go 1.22+
+
+module Hydra.Go.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 Go 1.22+
+goLanguage :: Coders.Language
+goLanguage =
+    Coders.Language {
+      Coders.languageName = (Coders.LanguageName "hydra.go"),
+      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.CaseConventionPascal,
+        Coders.caseConventionsField = Util.CaseConventionCamel,
+        Coders.caseConventionsFile = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsModule = Util.CaseConventionLowerSnake,
+        Coders.caseConventionsTerm = Util.CaseConventionCamel,
+        Coders.caseConventionsTermVariable = Util.CaseConventionCamel,
+        Coders.caseConventionsType = Util.CaseConventionPascal,
+        Coders.caseConventionsTypeVariable = Util.CaseConventionPascal},
+      Coders.languageDefaultFileExtension = (File.FileExtension "go")}
+  where
+    literalVariants =
+        Sets.fromList [
+          Variants.LiteralVariantBinary,
+          Variants.LiteralVariantBoolean,
+          Variants.LiteralVariantFloat,
+          Variants.LiteralVariantInteger,
+          Variants.LiteralVariantString]
+    floatTypes =
+        Sets.fromList [
+          Core.FloatTypeFloat32,
+          Core.FloatTypeFloat64]
+    integerTypes =
+        Sets.fromList [
+          Core.IntegerTypeBigint,
+          Core.IntegerTypeInt8,
+          Core.IntegerTypeInt16,
+          Core.IntegerTypeInt32,
+          Core.IntegerTypeInt64,
+          Core.IntegerTypeUint8,
+          Core.IntegerTypeUint16,
+          Core.IntegerTypeUint32,
+          Core.IntegerTypeUint64]
+    termVariants =
+        Sets.fromList [
+          Variants.TermVariantAnnotated,
+          Variants.TermVariantApplication,
+          Variants.TermVariantEither,
+          Variants.TermVariantCases,
+          Variants.TermVariantLambda,
+          Variants.TermVariantProject,
+          Variants.TermVariantUnwrap,
+          Variants.TermVariantLet,
+          Variants.TermVariantList,
+          Variants.TermVariantLiteral,
+          Variants.TermVariantMap,
+          Variants.TermVariantOptional,
+          Variants.TermVariantPair,
+          Variants.TermVariantRecord,
+          Variants.TermVariantSet,
+          Variants.TermVariantTypeApplication,
+          Variants.TermVariantTypeLambda,
+          Variants.TermVariantInject,
+          Variants.TermVariantUnit,
+          Variants.TermVariantVariable,
+          Variants.TermVariantWrap]
+    typeVariants =
+        Sets.fromList [
+          Variants.TypeVariantAnnotated,
+          Variants.TypeVariantApplication,
+          Variants.TypeVariantEither,
+          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 in Go
+goReservedWords :: S.Set String
+goReservedWords =
+    Sets.fromList (Lists.concat [
+      goKeywords,
+      goPredeclaredIdentifiers,
+      hydraGoKeywords])
+  where
+    goKeywords =
+        [
+          "break",
+          "case",
+          "chan",
+          "const",
+          "continue",
+          "default",
+          "defer",
+          "else",
+          "fallthrough",
+          "for",
+          "func",
+          "go",
+          "goto",
+          "if",
+          "import",
+          "interface",
+          "map",
+          "package",
+          "range",
+          "return",
+          "select",
+          "struct",
+          "switch",
+          "type",
+          "var"]
+    goPredeclaredIdentifiers =
+        [
+          "any",
+          "bool",
+          "byte",
+          "comparable",
+          "complex64",
+          "complex128",
+          "error",
+          "float32",
+          "float64",
+          "int",
+          "int8",
+          "int16",
+          "int32",
+          "int64",
+          "rune",
+          "string",
+          "uint",
+          "uint8",
+          "uint16",
+          "uint32",
+          "uint64",
+          "uintptr",
+          "true",
+          "false",
+          "iota",
+          "nil",
+          "append",
+          "cap",
+          "clear",
+          "close",
+          "complex",
+          "copy",
+          "delete",
+          "imag",
+          "len",
+          "make",
+          "max",
+          "min",
+          "new",
+          "panic",
+          "print",
+          "println",
+          "real",
+          "recover"]
+    hydraGoKeywords =
+        [
+          "Node",
+          "Maybe",
+          "Either",
+          "Left",
+          "Right",
+          "Just",
+          "Nothing",
+          "Unit",
+          "Pair"]
diff --git a/src/main/haskell/Hydra/Go/Syntax.hs b/src/main/haskell/Hydra/Go/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Go/Syntax.hs
@@ -0,0 +1,1623 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | A Go syntax model, based on the Go Language Specification retrieved on 2025-02-05 from https://go.dev/ref/spec
+
+module Hydra.Go.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
+
+data AnnotatedDeclaration =
+  AnnotatedDeclaration {
+    annotatedDeclarationComment :: String,
+    annotatedDeclarationDeclaration :: TopLevelDecl}
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotatedDeclaration = Core.Name "hydra.go.syntax.AnnotatedDeclaration"
+
+_AnnotatedDeclaration_comment = Core.Name "comment"
+
+_AnnotatedDeclaration_declaration = Core.Name "declaration"
+
+data Module =
+  Module {
+    modulePackage :: PackageClause,
+    moduleImports :: [ImportDecl],
+    moduleDeclarations :: [TopLevelDecl]}
+  deriving (Eq, Ord, Read, Show)
+
+_Module = Core.Name "hydra.go.syntax.Module"
+
+_Module_package = Core.Name "package"
+
+_Module_imports = Core.Name "imports"
+
+_Module_declarations = Core.Name "declarations"
+
+newtype Identifier =
+  Identifier {
+    unIdentifier :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_Identifier = Core.Name "hydra.go.syntax.Identifier"
+
+newtype IntLit =
+  IntLit {
+    unIntLit :: Integer}
+  deriving (Eq, Ord, Read, Show)
+
+_IntLit = Core.Name "hydra.go.syntax.IntLit"
+
+newtype FloatLit =
+  FloatLit {
+    unFloatLit :: Double}
+  deriving (Eq, Ord, Read, Show)
+
+_FloatLit = Core.Name "hydra.go.syntax.FloatLit"
+
+newtype ImaginaryLit =
+  ImaginaryLit {
+    unImaginaryLit :: Double}
+  deriving (Eq, Ord, Read, Show)
+
+_ImaginaryLit = Core.Name "hydra.go.syntax.ImaginaryLit"
+
+newtype RuneLit =
+  RuneLit {
+    unRuneLit :: Int}
+  deriving (Eq, Ord, Read, Show)
+
+_RuneLit = Core.Name "hydra.go.syntax.RuneLit"
+
+data StringLit =
+  StringLitRaw RawStringLit |
+  StringLitInterpreted InterpretedStringLit
+  deriving (Eq, Ord, Read, Show)
+
+_StringLit = Core.Name "hydra.go.syntax.StringLit"
+
+_StringLit_raw = Core.Name "raw"
+
+_StringLit_interpreted = Core.Name "interpreted"
+
+newtype RawStringLit =
+  RawStringLit {
+    unRawStringLit :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_RawStringLit = Core.Name "hydra.go.syntax.RawStringLit"
+
+newtype InterpretedStringLit =
+  InterpretedStringLit {
+    unInterpretedStringLit :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_InterpretedStringLit = Core.Name "hydra.go.syntax.InterpretedStringLit"
+
+data SourceFile =
+  SourceFile {
+    sourceFilePackage :: PackageClause,
+    sourceFileImports :: [ImportDecl],
+    sourceFileDeclarations :: [TopLevelDecl]}
+  deriving (Eq, Ord, Read, Show)
+
+_SourceFile = Core.Name "hydra.go.syntax.SourceFile"
+
+_SourceFile_package = Core.Name "package"
+
+_SourceFile_imports = Core.Name "imports"
+
+_SourceFile_declarations = Core.Name "declarations"
+
+newtype PackageClause =
+  PackageClause {
+    unPackageClause :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_PackageClause = Core.Name "hydra.go.syntax.PackageClause"
+
+newtype ImportDecl =
+  ImportDecl {
+    unImportDecl :: [ImportSpec]}
+  deriving (Eq, Ord, Read, Show)
+
+_ImportDecl = Core.Name "hydra.go.syntax.ImportDecl"
+
+data ImportSpec =
+  ImportSpec {
+    importSpecAlias :: (Maybe ImportAlias),
+    importSpecPath :: ImportPath}
+  deriving (Eq, Ord, Read, Show)
+
+_ImportSpec = Core.Name "hydra.go.syntax.ImportSpec"
+
+_ImportSpec_alias = Core.Name "alias"
+
+_ImportSpec_path = Core.Name "path"
+
+data ImportAlias =
+  ImportAliasDot |
+  ImportAliasName Identifier
+  deriving (Eq, Ord, Read, Show)
+
+_ImportAlias = Core.Name "hydra.go.syntax.ImportAlias"
+
+_ImportAlias_dot = Core.Name "dot"
+
+_ImportAlias_name = Core.Name "name"
+
+newtype ImportPath =
+  ImportPath {
+    unImportPath :: StringLit}
+  deriving (Eq, Ord, Read, Show)
+
+_ImportPath = Core.Name "hydra.go.syntax.ImportPath"
+
+data Declaration =
+  DeclarationConst ConstDecl |
+  DeclarationType TypeDecl |
+  DeclarationVar VarDecl
+  deriving (Eq, Ord, Read, Show)
+
+_Declaration = Core.Name "hydra.go.syntax.Declaration"
+
+_Declaration_const = Core.Name "const"
+
+_Declaration_type = Core.Name "type"
+
+_Declaration_var = Core.Name "var"
+
+data TopLevelDecl =
+  TopLevelDeclDeclaration Declaration |
+  TopLevelDeclFunction FunctionDecl |
+  TopLevelDeclMethod MethodDecl
+  deriving (Eq, Ord, Read, Show)
+
+_TopLevelDecl = Core.Name "hydra.go.syntax.TopLevelDecl"
+
+_TopLevelDecl_declaration = Core.Name "declaration"
+
+_TopLevelDecl_function = Core.Name "function"
+
+_TopLevelDecl_method = Core.Name "method"
+
+newtype ConstDecl =
+  ConstDecl {
+    unConstDecl :: [ConstSpec]}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstDecl = Core.Name "hydra.go.syntax.ConstDecl"
+
+data ConstSpec =
+  ConstSpec {
+    constSpecNames :: [Identifier],
+    constSpecType :: (Maybe Type),
+    constSpecValues :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstSpec = Core.Name "hydra.go.syntax.ConstSpec"
+
+_ConstSpec_names = Core.Name "names"
+
+_ConstSpec_type = Core.Name "type"
+
+_ConstSpec_values = Core.Name "values"
+
+newtype VarDecl =
+  VarDecl {
+    unVarDecl :: [VarSpec]}
+  deriving (Eq, Ord, Read, Show)
+
+_VarDecl = Core.Name "hydra.go.syntax.VarDecl"
+
+data VarSpec =
+  VarSpec {
+    varSpecNames :: [Identifier],
+    varSpecType :: (Maybe Type),
+    varSpecValues :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_VarSpec = Core.Name "hydra.go.syntax.VarSpec"
+
+_VarSpec_names = Core.Name "names"
+
+_VarSpec_type = Core.Name "type"
+
+_VarSpec_values = Core.Name "values"
+
+data ShortVarDecl =
+  ShortVarDecl {
+    shortVarDeclNames :: [Identifier],
+    shortVarDeclValues :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_ShortVarDecl = Core.Name "hydra.go.syntax.ShortVarDecl"
+
+_ShortVarDecl_names = Core.Name "names"
+
+_ShortVarDecl_values = Core.Name "values"
+
+newtype TypeDecl =
+  TypeDecl {
+    unTypeDecl :: [TypeSpec]}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeDecl = Core.Name "hydra.go.syntax.TypeDecl"
+
+data TypeSpec =
+  TypeSpecAlias AliasDecl |
+  TypeSpecDefinition TypeDef
+  deriving (Eq, Ord, Read, Show)
+
+_TypeSpec = Core.Name "hydra.go.syntax.TypeSpec"
+
+_TypeSpec_alias = Core.Name "alias"
+
+_TypeSpec_definition = Core.Name "definition"
+
+data AliasDecl =
+  AliasDecl {
+    aliasDeclName :: Identifier,
+    aliasDeclType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_AliasDecl = Core.Name "hydra.go.syntax.AliasDecl"
+
+_AliasDecl_name = Core.Name "name"
+
+_AliasDecl_type = Core.Name "type"
+
+data TypeDef =
+  TypeDef {
+    typeDefName :: Identifier,
+    typeDefTypeParams :: (Maybe TypeParameters),
+    typeDefType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeDef = Core.Name "hydra.go.syntax.TypeDef"
+
+_TypeDef_name = Core.Name "name"
+
+_TypeDef_typeParams = Core.Name "typeParams"
+
+_TypeDef_type = Core.Name "type"
+
+newtype TypeParameters =
+  TypeParameters {
+    unTypeParameters :: [TypeParamDecl]}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeParameters = Core.Name "hydra.go.syntax.TypeParameters"
+
+data TypeParamDecl =
+  TypeParamDecl {
+    typeParamDeclNames :: [Identifier],
+    typeParamDeclConstraint :: TypeConstraint}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeParamDecl = Core.Name "hydra.go.syntax.TypeParamDecl"
+
+_TypeParamDecl_names = Core.Name "names"
+
+_TypeParamDecl_constraint = Core.Name "constraint"
+
+newtype TypeConstraint =
+  TypeConstraint {
+    unTypeConstraint :: TypeElem}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeConstraint = Core.Name "hydra.go.syntax.TypeConstraint"
+
+data FunctionDecl =
+  FunctionDecl {
+    functionDeclName :: Identifier,
+    functionDeclTypeParams :: (Maybe TypeParameters),
+    functionDeclSignature :: Signature,
+    functionDeclBody :: (Maybe FunctionBody)}
+  deriving (Eq, Ord, Read, Show)
+
+_FunctionDecl = Core.Name "hydra.go.syntax.FunctionDecl"
+
+_FunctionDecl_name = Core.Name "name"
+
+_FunctionDecl_typeParams = Core.Name "typeParams"
+
+_FunctionDecl_signature = Core.Name "signature"
+
+_FunctionDecl_body = Core.Name "body"
+
+newtype FunctionBody =
+  FunctionBody {
+    unFunctionBody :: Block}
+  deriving (Eq, Ord, Read, Show)
+
+_FunctionBody = Core.Name "hydra.go.syntax.FunctionBody"
+
+data MethodDecl =
+  MethodDecl {
+    methodDeclReceiver :: Receiver,
+    methodDeclName :: Identifier,
+    methodDeclSignature :: Signature,
+    methodDeclBody :: (Maybe FunctionBody)}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodDecl = Core.Name "hydra.go.syntax.MethodDecl"
+
+_MethodDecl_receiver = Core.Name "receiver"
+
+_MethodDecl_name = Core.Name "name"
+
+_MethodDecl_signature = Core.Name "signature"
+
+_MethodDecl_body = Core.Name "body"
+
+data Receiver =
+  Receiver {
+    receiverName :: (Maybe Identifier),
+    receiverType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_Receiver = Core.Name "hydra.go.syntax.Receiver"
+
+_Receiver_name = Core.Name "name"
+
+_Receiver_type = Core.Name "type"
+
+data Type =
+  TypeName_ TypeName |
+  TypeLiteral TypeLit |
+  TypeParen Type
+  deriving (Eq, Ord, Read, Show)
+
+_Type = Core.Name "hydra.go.syntax.Type"
+
+_Type_name = Core.Name "name"
+
+_Type_literal = Core.Name "literal"
+
+_Type_paren = Core.Name "paren"
+
+data TypeName =
+  TypeName {
+    typeNameName :: QualifiedIdent,
+    typeNameTypeArgs :: [Type]}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeName = Core.Name "hydra.go.syntax.TypeName"
+
+_TypeName_name = Core.Name "name"
+
+_TypeName_typeArgs = Core.Name "typeArgs"
+
+data QualifiedIdent =
+  QualifiedIdent {
+    qualifiedIdentPackage :: (Maybe Identifier),
+    qualifiedIdentName :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_QualifiedIdent = Core.Name "hydra.go.syntax.QualifiedIdent"
+
+_QualifiedIdent_package = Core.Name "package"
+
+_QualifiedIdent_name = Core.Name "name"
+
+data TypeLit =
+  TypeLitArray ArrayType |
+  TypeLitStruct StructType |
+  TypeLitPointer PointerType |
+  TypeLitFunction FunctionType |
+  TypeLitInterface InterfaceType |
+  TypeLitSlice SliceType |
+  TypeLitMap MapType |
+  TypeLitChannel ChannelType
+  deriving (Eq, Ord, Read, Show)
+
+_TypeLit = Core.Name "hydra.go.syntax.TypeLit"
+
+_TypeLit_array = Core.Name "array"
+
+_TypeLit_struct = Core.Name "struct"
+
+_TypeLit_pointer = Core.Name "pointer"
+
+_TypeLit_function = Core.Name "function"
+
+_TypeLit_interface = Core.Name "interface"
+
+_TypeLit_slice = Core.Name "slice"
+
+_TypeLit_map = Core.Name "map"
+
+_TypeLit_channel = Core.Name "channel"
+
+data ArrayType =
+  ArrayType {
+    arrayTypeLength :: Expression,
+    arrayTypeElement :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayType = Core.Name "hydra.go.syntax.ArrayType"
+
+_ArrayType_length = Core.Name "length"
+
+_ArrayType_element = Core.Name "element"
+
+newtype SliceType =
+  SliceType {
+    unSliceType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_SliceType = Core.Name "hydra.go.syntax.SliceType"
+
+newtype StructType =
+  StructType {
+    unStructType :: [FieldDecl]}
+  deriving (Eq, Ord, Read, Show)
+
+_StructType = Core.Name "hydra.go.syntax.StructType"
+
+data FieldDecl =
+  FieldDeclNamed NamedField |
+  FieldDeclEmbedded EmbeddedField
+  deriving (Eq, Ord, Read, Show)
+
+_FieldDecl = Core.Name "hydra.go.syntax.FieldDecl"
+
+_FieldDecl_named = Core.Name "named"
+
+_FieldDecl_embedded = Core.Name "embedded"
+
+data NamedField =
+  NamedField {
+    namedFieldNames :: [Identifier],
+    namedFieldType :: Type,
+    namedFieldTag :: (Maybe Tag)}
+  deriving (Eq, Ord, Read, Show)
+
+_NamedField = Core.Name "hydra.go.syntax.NamedField"
+
+_NamedField_names = Core.Name "names"
+
+_NamedField_type = Core.Name "type"
+
+_NamedField_tag = Core.Name "tag"
+
+data EmbeddedField =
+  EmbeddedField {
+    embeddedFieldPointer :: Bool,
+    embeddedFieldType :: TypeName,
+    embeddedFieldTag :: (Maybe Tag)}
+  deriving (Eq, Ord, Read, Show)
+
+_EmbeddedField = Core.Name "hydra.go.syntax.EmbeddedField"
+
+_EmbeddedField_pointer = Core.Name "pointer"
+
+_EmbeddedField_type = Core.Name "type"
+
+_EmbeddedField_tag = Core.Name "tag"
+
+newtype Tag =
+  Tag {
+    unTag :: StringLit}
+  deriving (Eq, Ord, Read, Show)
+
+_Tag = Core.Name "hydra.go.syntax.Tag"
+
+newtype PointerType =
+  PointerType {
+    unPointerType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_PointerType = Core.Name "hydra.go.syntax.PointerType"
+
+newtype FunctionType =
+  FunctionType {
+    unFunctionType :: Signature}
+  deriving (Eq, Ord, Read, Show)
+
+_FunctionType = Core.Name "hydra.go.syntax.FunctionType"
+
+data Signature =
+  Signature {
+    signatureParameters :: Parameters,
+    signatureResult :: (Maybe Result)}
+  deriving (Eq, Ord, Read, Show)
+
+_Signature = Core.Name "hydra.go.syntax.Signature"
+
+_Signature_parameters = Core.Name "parameters"
+
+_Signature_result = Core.Name "result"
+
+data Result =
+  ResultParameters Parameters |
+  ResultType Type
+  deriving (Eq, Ord, Read, Show)
+
+_Result = Core.Name "hydra.go.syntax.Result"
+
+_Result_parameters = Core.Name "parameters"
+
+_Result_type = Core.Name "type"
+
+newtype Parameters =
+  Parameters {
+    unParameters :: [ParameterDecl]}
+  deriving (Eq, Ord, Read, Show)
+
+_Parameters = Core.Name "hydra.go.syntax.Parameters"
+
+data ParameterDecl =
+  ParameterDecl {
+    parameterDeclNames :: [Identifier],
+    parameterDeclVariadic :: Bool,
+    parameterDeclType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ParameterDecl = Core.Name "hydra.go.syntax.ParameterDecl"
+
+_ParameterDecl_names = Core.Name "names"
+
+_ParameterDecl_variadic = Core.Name "variadic"
+
+_ParameterDecl_type = Core.Name "type"
+
+newtype InterfaceType =
+  InterfaceType {
+    unInterfaceType :: [InterfaceElem]}
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceType = Core.Name "hydra.go.syntax.InterfaceType"
+
+data InterfaceElem =
+  InterfaceElemMethod MethodElem |
+  InterfaceElemType TypeElem
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceElem = Core.Name "hydra.go.syntax.InterfaceElem"
+
+_InterfaceElem_method = Core.Name "method"
+
+_InterfaceElem_type = Core.Name "type"
+
+data MethodElem =
+  MethodElem {
+    methodElemName :: Identifier,
+    methodElemSignature :: Signature}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodElem = Core.Name "hydra.go.syntax.MethodElem"
+
+_MethodElem_name = Core.Name "name"
+
+_MethodElem_signature = Core.Name "signature"
+
+newtype TypeElem =
+  TypeElem {
+    unTypeElem :: [TypeTerm]}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeElem = Core.Name "hydra.go.syntax.TypeElem"
+
+data TypeTerm =
+  TypeTerm {
+    typeTermUnderlying :: Bool,
+    typeTermType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeTerm = Core.Name "hydra.go.syntax.TypeTerm"
+
+_TypeTerm_underlying = Core.Name "underlying"
+
+_TypeTerm_type = Core.Name "type"
+
+data MapType =
+  MapType {
+    mapTypeKey :: Type,
+    mapTypeValue :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_MapType = Core.Name "hydra.go.syntax.MapType"
+
+_MapType_key = Core.Name "key"
+
+_MapType_value = Core.Name "value"
+
+data ChannelType =
+  ChannelType {
+    channelTypeDirection :: ChannelDirection,
+    channelTypeElement :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ChannelType = Core.Name "hydra.go.syntax.ChannelType"
+
+_ChannelType_direction = Core.Name "direction"
+
+_ChannelType_element = Core.Name "element"
+
+data ChannelDirection =
+  ChannelDirectionBidirectional |
+  ChannelDirectionSend |
+  ChannelDirectionReceive
+  deriving (Eq, Ord, Read, Show)
+
+_ChannelDirection = Core.Name "hydra.go.syntax.ChannelDirection"
+
+_ChannelDirection_bidirectional = Core.Name "bidirectional"
+
+_ChannelDirection_send = Core.Name "send"
+
+_ChannelDirection_receive = Core.Name "receive"
+
+data Expression =
+  ExpressionUnary UnaryExpr |
+  ExpressionBinary BinaryExpr
+  deriving (Eq, Ord, Read, Show)
+
+_Expression = Core.Name "hydra.go.syntax.Expression"
+
+_Expression_unary = Core.Name "unary"
+
+_Expression_binary = Core.Name "binary"
+
+data UnaryExpr =
+  UnaryExprPrimary PrimaryExpr |
+  UnaryExprOp UnaryOperation
+  deriving (Eq, Ord, Read, Show)
+
+_UnaryExpr = Core.Name "hydra.go.syntax.UnaryExpr"
+
+_UnaryExpr_primary = Core.Name "primary"
+
+_UnaryExpr_op = Core.Name "op"
+
+data UnaryOperation =
+  UnaryOperation {
+    unaryOperationOp :: UnaryOp,
+    unaryOperationOperand :: UnaryExpr}
+  deriving (Eq, Ord, Read, Show)
+
+_UnaryOperation = Core.Name "hydra.go.syntax.UnaryOperation"
+
+_UnaryOperation_op = Core.Name "op"
+
+_UnaryOperation_operand = Core.Name "operand"
+
+data BinaryExpr =
+  BinaryExpr {
+    binaryExprLeft :: Expression,
+    binaryExprOp :: BinaryOp,
+    binaryExprRight :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_BinaryExpr = Core.Name "hydra.go.syntax.BinaryExpr"
+
+_BinaryExpr_left = Core.Name "left"
+
+_BinaryExpr_op = Core.Name "op"
+
+_BinaryExpr_right = Core.Name "right"
+
+data BinaryOp =
+  BinaryOpOr |
+  BinaryOpAnd |
+  BinaryOpEqual |
+  BinaryOpNotEqual |
+  BinaryOpLess |
+  BinaryOpLessEqual |
+  BinaryOpGreater |
+  BinaryOpGreaterEqual |
+  BinaryOpAdd |
+  BinaryOpSubtract |
+  BinaryOpBitwiseOr |
+  BinaryOpBitwiseXor |
+  BinaryOpMultiply |
+  BinaryOpDivide |
+  BinaryOpRemainder |
+  BinaryOpLeftShift |
+  BinaryOpRightShift |
+  BinaryOpBitwiseAnd |
+  BinaryOpBitClear
+  deriving (Eq, Ord, Read, Show)
+
+_BinaryOp = Core.Name "hydra.go.syntax.BinaryOp"
+
+_BinaryOp_or = Core.Name "or"
+
+_BinaryOp_and = Core.Name "and"
+
+_BinaryOp_equal = Core.Name "equal"
+
+_BinaryOp_notEqual = Core.Name "notEqual"
+
+_BinaryOp_less = Core.Name "less"
+
+_BinaryOp_lessEqual = Core.Name "lessEqual"
+
+_BinaryOp_greater = Core.Name "greater"
+
+_BinaryOp_greaterEqual = Core.Name "greaterEqual"
+
+_BinaryOp_add = Core.Name "add"
+
+_BinaryOp_subtract = Core.Name "subtract"
+
+_BinaryOp_bitwiseOr = Core.Name "bitwiseOr"
+
+_BinaryOp_bitwiseXor = Core.Name "bitwiseXor"
+
+_BinaryOp_multiply = Core.Name "multiply"
+
+_BinaryOp_divide = Core.Name "divide"
+
+_BinaryOp_remainder = Core.Name "remainder"
+
+_BinaryOp_leftShift = Core.Name "leftShift"
+
+_BinaryOp_rightShift = Core.Name "rightShift"
+
+_BinaryOp_bitwiseAnd = Core.Name "bitwiseAnd"
+
+_BinaryOp_bitClear = Core.Name "bitClear"
+
+data PrimaryExpr =
+  PrimaryExprOperand Operand |
+  PrimaryExprConversion Conversion |
+  PrimaryExprMethodExpr MethodExpr |
+  PrimaryExprSelector SelectorExpr |
+  PrimaryExprIndex IndexExpr |
+  PrimaryExprSlice SliceExpr |
+  PrimaryExprTypeAssertion TypeAssertionExpr |
+  PrimaryExprCall CallExpr
+  deriving (Eq, Ord, Read, Show)
+
+_PrimaryExpr = Core.Name "hydra.go.syntax.PrimaryExpr"
+
+_PrimaryExpr_operand = Core.Name "operand"
+
+_PrimaryExpr_conversion = Core.Name "conversion"
+
+_PrimaryExpr_methodExpr = Core.Name "methodExpr"
+
+_PrimaryExpr_selector = Core.Name "selector"
+
+_PrimaryExpr_index = Core.Name "index"
+
+_PrimaryExpr_slice = Core.Name "slice"
+
+_PrimaryExpr_typeAssertion = Core.Name "typeAssertion"
+
+_PrimaryExpr_call = Core.Name "call"
+
+data SelectorExpr =
+  SelectorExpr {
+    selectorExprExpr :: PrimaryExpr,
+    selectorExprSelector :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_SelectorExpr = Core.Name "hydra.go.syntax.SelectorExpr"
+
+_SelectorExpr_expr = Core.Name "expr"
+
+_SelectorExpr_selector = Core.Name "selector"
+
+data IndexExpr =
+  IndexExpr {
+    indexExprExpr :: PrimaryExpr,
+    indexExprIndex :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_IndexExpr = Core.Name "hydra.go.syntax.IndexExpr"
+
+_IndexExpr_expr = Core.Name "expr"
+
+_IndexExpr_index = Core.Name "index"
+
+data SliceExpr =
+  SliceExpr {
+    sliceExprExpr :: PrimaryExpr,
+    sliceExprSlice :: Slice}
+  deriving (Eq, Ord, Read, Show)
+
+_SliceExpr = Core.Name "hydra.go.syntax.SliceExpr"
+
+_SliceExpr_expr = Core.Name "expr"
+
+_SliceExpr_slice = Core.Name "slice"
+
+data TypeAssertionExpr =
+  TypeAssertionExpr {
+    typeAssertionExprExpr :: PrimaryExpr,
+    typeAssertionExprType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeAssertionExpr = Core.Name "hydra.go.syntax.TypeAssertionExpr"
+
+_TypeAssertionExpr_expr = Core.Name "expr"
+
+_TypeAssertionExpr_type = Core.Name "type"
+
+data CallExpr =
+  CallExpr {
+    callExprFunction :: PrimaryExpr,
+    callExprArguments :: Arguments}
+  deriving (Eq, Ord, Read, Show)
+
+_CallExpr = Core.Name "hydra.go.syntax.CallExpr"
+
+_CallExpr_function = Core.Name "function"
+
+_CallExpr_arguments = Core.Name "arguments"
+
+data Operand =
+  OperandLiteral Literal |
+  OperandName_ OperandName |
+  OperandParen Expression
+  deriving (Eq, Ord, Read, Show)
+
+_Operand = Core.Name "hydra.go.syntax.Operand"
+
+_Operand_literal = Core.Name "literal"
+
+_Operand_name = Core.Name "name"
+
+_Operand_paren = Core.Name "paren"
+
+data OperandName =
+  OperandName {
+    operandNameName :: QualifiedIdent,
+    operandNameTypeArgs :: [Type]}
+  deriving (Eq, Ord, Read, Show)
+
+_OperandName = Core.Name "hydra.go.syntax.OperandName"
+
+_OperandName_name = Core.Name "name"
+
+_OperandName_typeArgs = Core.Name "typeArgs"
+
+data Literal =
+  LiteralBasic BasicLit |
+  LiteralComposite CompositeLit |
+  LiteralFunction FunctionLit
+  deriving (Eq, Ord, Read, Show)
+
+_Literal = Core.Name "hydra.go.syntax.Literal"
+
+_Literal_basic = Core.Name "basic"
+
+_Literal_composite = Core.Name "composite"
+
+_Literal_function = Core.Name "function"
+
+data BasicLit =
+  BasicLitInt IntLit |
+  BasicLitFloat FloatLit |
+  BasicLitImaginary ImaginaryLit |
+  BasicLitRune RuneLit |
+  BasicLitString StringLit
+  deriving (Eq, Ord, Read, Show)
+
+_BasicLit = Core.Name "hydra.go.syntax.BasicLit"
+
+_BasicLit_int = Core.Name "int"
+
+_BasicLit_float = Core.Name "float"
+
+_BasicLit_imaginary = Core.Name "imaginary"
+
+_BasicLit_rune = Core.Name "rune"
+
+_BasicLit_string = Core.Name "string"
+
+data CompositeLit =
+  CompositeLit {
+    compositeLitType :: LiteralType,
+    compositeLitValue :: LiteralValue}
+  deriving (Eq, Ord, Read, Show)
+
+_CompositeLit = Core.Name "hydra.go.syntax.CompositeLit"
+
+_CompositeLit_type = Core.Name "type"
+
+_CompositeLit_value = Core.Name "value"
+
+data LiteralType =
+  LiteralTypeStruct StructType |
+  LiteralTypeArray ArrayType |
+  LiteralTypeInferredArray Type |
+  LiteralTypeSlice SliceType |
+  LiteralTypeMap MapType |
+  LiteralTypeName TypeName
+  deriving (Eq, Ord, Read, Show)
+
+_LiteralType = Core.Name "hydra.go.syntax.LiteralType"
+
+_LiteralType_struct = Core.Name "struct"
+
+_LiteralType_array = Core.Name "array"
+
+_LiteralType_inferredArray = Core.Name "inferredArray"
+
+_LiteralType_slice = Core.Name "slice"
+
+_LiteralType_map = Core.Name "map"
+
+_LiteralType_name = Core.Name "name"
+
+newtype LiteralValue =
+  LiteralValue {
+    unLiteralValue :: [KeyedElement]}
+  deriving (Eq, Ord, Read, Show)
+
+_LiteralValue = Core.Name "hydra.go.syntax.LiteralValue"
+
+newtype ElementList =
+  ElementList {
+    unElementList :: [KeyedElement]}
+  deriving (Eq, Ord, Read, Show)
+
+_ElementList = Core.Name "hydra.go.syntax.ElementList"
+
+data KeyedElement =
+  KeyedElement {
+    keyedElementKey :: (Maybe Key),
+    keyedElementElement :: Element}
+  deriving (Eq, Ord, Read, Show)
+
+_KeyedElement = Core.Name "hydra.go.syntax.KeyedElement"
+
+_KeyedElement_key = Core.Name "key"
+
+_KeyedElement_element = Core.Name "element"
+
+data Key =
+  KeyField Identifier |
+  KeyExpression Expression |
+  KeyLiteral LiteralValue
+  deriving (Eq, Ord, Read, Show)
+
+_Key = Core.Name "hydra.go.syntax.Key"
+
+_Key_field = Core.Name "field"
+
+_Key_expression = Core.Name "expression"
+
+_Key_literal = Core.Name "literal"
+
+data Element =
+  ElementExpression Expression |
+  ElementLiteral LiteralValue
+  deriving (Eq, Ord, Read, Show)
+
+_Element = Core.Name "hydra.go.syntax.Element"
+
+_Element_expression = Core.Name "expression"
+
+_Element_literal = Core.Name "literal"
+
+data FunctionLit =
+  FunctionLit {
+    functionLitSignature :: Signature,
+    functionLitBody :: FunctionBody}
+  deriving (Eq, Ord, Read, Show)
+
+_FunctionLit = Core.Name "hydra.go.syntax.FunctionLit"
+
+_FunctionLit_signature = Core.Name "signature"
+
+_FunctionLit_body = Core.Name "body"
+
+newtype Selector =
+  Selector {
+    unSelector :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_Selector = Core.Name "hydra.go.syntax.Selector"
+
+newtype Index =
+  Index {
+    unIndex :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_Index = Core.Name "hydra.go.syntax.Index"
+
+data Slice =
+  SliceSimple SimpleSlice |
+  SliceFull FullSlice
+  deriving (Eq, Ord, Read, Show)
+
+_Slice = Core.Name "hydra.go.syntax.Slice"
+
+_Slice_simple = Core.Name "simple"
+
+_Slice_full = Core.Name "full"
+
+data SimpleSlice =
+  SimpleSlice {
+    simpleSliceLow :: (Maybe Expression),
+    simpleSliceHigh :: (Maybe Expression)}
+  deriving (Eq, Ord, Read, Show)
+
+_SimpleSlice = Core.Name "hydra.go.syntax.SimpleSlice"
+
+_SimpleSlice_low = Core.Name "low"
+
+_SimpleSlice_high = Core.Name "high"
+
+data FullSlice =
+  FullSlice {
+    fullSliceLow :: (Maybe Expression),
+    fullSliceHigh :: Expression,
+    fullSliceMax :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_FullSlice = Core.Name "hydra.go.syntax.FullSlice"
+
+_FullSlice_low = Core.Name "low"
+
+_FullSlice_high = Core.Name "high"
+
+_FullSlice_max = Core.Name "max"
+
+newtype TypeAssertion =
+  TypeAssertion {
+    unTypeAssertion :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeAssertion = Core.Name "hydra.go.syntax.TypeAssertion"
+
+data Arguments =
+  Arguments {
+    argumentsTypeArg :: (Maybe Type),
+    argumentsExpressions :: [Expression],
+    argumentsEllipsis :: Bool}
+  deriving (Eq, Ord, Read, Show)
+
+_Arguments = Core.Name "hydra.go.syntax.Arguments"
+
+_Arguments_typeArg = Core.Name "typeArg"
+
+_Arguments_expressions = Core.Name "expressions"
+
+_Arguments_ellipsis = Core.Name "ellipsis"
+
+data MethodExpr =
+  MethodExpr {
+    methodExprReceiver :: Type,
+    methodExprMethod :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodExpr = Core.Name "hydra.go.syntax.MethodExpr"
+
+_MethodExpr_receiver = Core.Name "receiver"
+
+_MethodExpr_method = Core.Name "method"
+
+data Conversion =
+  Conversion {
+    conversionType :: Type,
+    conversionExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_Conversion = Core.Name "hydra.go.syntax.Conversion"
+
+_Conversion_type = Core.Name "type"
+
+_Conversion_expression = Core.Name "expression"
+
+data Statement =
+  StatementDeclaration Declaration |
+  StatementLabeled LabeledStmt |
+  StatementSimple SimpleStmt |
+  StatementGo GoStmt |
+  StatementReturn ReturnStmt |
+  StatementBreak BreakStmt |
+  StatementContinue ContinueStmt |
+  StatementGoto GotoStmt |
+  StatementFallthrough FallthroughStmt |
+  StatementBlock Block |
+  StatementIf IfStmt |
+  StatementSwitch SwitchStmt |
+  StatementSelect SelectStmt |
+  StatementFor ForStmt |
+  StatementDefer DeferStmt
+  deriving (Eq, Ord, Read, Show)
+
+_Statement = Core.Name "hydra.go.syntax.Statement"
+
+_Statement_declaration = Core.Name "declaration"
+
+_Statement_labeled = Core.Name "labeled"
+
+_Statement_simple = Core.Name "simple"
+
+_Statement_go = Core.Name "go"
+
+_Statement_return = Core.Name "return"
+
+_Statement_break = Core.Name "break"
+
+_Statement_continue = Core.Name "continue"
+
+_Statement_goto = Core.Name "goto"
+
+_Statement_fallthrough = Core.Name "fallthrough"
+
+_Statement_block = Core.Name "block"
+
+_Statement_if = Core.Name "if"
+
+_Statement_switch = Core.Name "switch"
+
+_Statement_select = Core.Name "select"
+
+_Statement_for = Core.Name "for"
+
+_Statement_defer = Core.Name "defer"
+
+data SimpleStmt =
+  SimpleStmtEmpty EmptyStmt |
+  SimpleStmtExpression ExpressionStmt |
+  SimpleStmtSend SendStmt |
+  SimpleStmtIncDec IncDecStmt |
+  SimpleStmtAssignment Assignment |
+  SimpleStmtShortVarDecl ShortVarDecl
+  deriving (Eq, Ord, Read, Show)
+
+_SimpleStmt = Core.Name "hydra.go.syntax.SimpleStmt"
+
+_SimpleStmt_empty = Core.Name "empty"
+
+_SimpleStmt_expression = Core.Name "expression"
+
+_SimpleStmt_send = Core.Name "send"
+
+_SimpleStmt_incDec = Core.Name "incDec"
+
+_SimpleStmt_assignment = Core.Name "assignment"
+
+_SimpleStmt_shortVarDecl = Core.Name "shortVarDecl"
+
+newtype EmptyStmt =
+  EmptyStmt {
+    unEmptyStmt :: ()}
+  deriving (Eq, Ord, Read, Show)
+
+_EmptyStmt = Core.Name "hydra.go.syntax.EmptyStmt"
+
+data LabeledStmt =
+  LabeledStmt {
+    labeledStmtLabel :: Identifier,
+    labeledStmtStatement :: Statement}
+  deriving (Eq, Ord, Read, Show)
+
+_LabeledStmt = Core.Name "hydra.go.syntax.LabeledStmt"
+
+_LabeledStmt_label = Core.Name "label"
+
+_LabeledStmt_statement = Core.Name "statement"
+
+newtype ExpressionStmt =
+  ExpressionStmt {
+    unExpressionStmt :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_ExpressionStmt = Core.Name "hydra.go.syntax.ExpressionStmt"
+
+data SendStmt =
+  SendStmt {
+    sendStmtChannel :: Expression,
+    sendStmtValue :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_SendStmt = Core.Name "hydra.go.syntax.SendStmt"
+
+_SendStmt_channel = Core.Name "channel"
+
+_SendStmt_value = Core.Name "value"
+
+data IncDecStmt =
+  IncDecStmt {
+    incDecStmtExpression :: Expression,
+    incDecStmtIncrement :: Bool}
+  deriving (Eq, Ord, Read, Show)
+
+_IncDecStmt = Core.Name "hydra.go.syntax.IncDecStmt"
+
+_IncDecStmt_expression = Core.Name "expression"
+
+_IncDecStmt_increment = Core.Name "increment"
+
+data Assignment =
+  Assignment {
+    assignmentLhs :: [Expression],
+    assignmentOp :: AssignOp,
+    assignmentRhs :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_Assignment = Core.Name "hydra.go.syntax.Assignment"
+
+_Assignment_lhs = Core.Name "lhs"
+
+_Assignment_op = Core.Name "op"
+
+_Assignment_rhs = Core.Name "rhs"
+
+data AssignOp =
+  AssignOpSimple |
+  AssignOpAdd AddOp |
+  AssignOpMul MulOp
+  deriving (Eq, Ord, Read, Show)
+
+_AssignOp = Core.Name "hydra.go.syntax.AssignOp"
+
+_AssignOp_simple = Core.Name "simple"
+
+_AssignOp_add = Core.Name "add"
+
+_AssignOp_mul = Core.Name "mul"
+
+data IfStmt =
+  IfStmt {
+    ifStmtInit :: (Maybe SimpleStmt),
+    ifStmtCondition :: Expression,
+    ifStmtThen :: Block,
+    ifStmtElse :: (Maybe ElseClause)}
+  deriving (Eq, Ord, Read, Show)
+
+_IfStmt = Core.Name "hydra.go.syntax.IfStmt"
+
+_IfStmt_init = Core.Name "init"
+
+_IfStmt_condition = Core.Name "condition"
+
+_IfStmt_then = Core.Name "then"
+
+_IfStmt_else = Core.Name "else"
+
+data ElseClause =
+  ElseClauseIf IfStmt |
+  ElseClauseBlock Block
+  deriving (Eq, Ord, Read, Show)
+
+_ElseClause = Core.Name "hydra.go.syntax.ElseClause"
+
+_ElseClause_if = Core.Name "if"
+
+_ElseClause_block = Core.Name "block"
+
+data SwitchStmt =
+  SwitchStmtExpression ExprSwitchStmt |
+  SwitchStmtType TypeSwitchStmt
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchStmt = Core.Name "hydra.go.syntax.SwitchStmt"
+
+_SwitchStmt_expression = Core.Name "expression"
+
+_SwitchStmt_type = Core.Name "type"
+
+data ExprSwitchStmt =
+  ExprSwitchStmt {
+    exprSwitchStmtInit :: (Maybe SimpleStmt),
+    exprSwitchStmtExpression :: (Maybe Expression),
+    exprSwitchStmtCases :: [ExprCaseClause]}
+  deriving (Eq, Ord, Read, Show)
+
+_ExprSwitchStmt = Core.Name "hydra.go.syntax.ExprSwitchStmt"
+
+_ExprSwitchStmt_init = Core.Name "init"
+
+_ExprSwitchStmt_expression = Core.Name "expression"
+
+_ExprSwitchStmt_cases = Core.Name "cases"
+
+data ExprCaseClause =
+  ExprCaseClause {
+    exprCaseClauseCase :: (Maybe [Expression]),
+    exprCaseClauseStatements :: [Statement]}
+  deriving (Eq, Ord, Read, Show)
+
+_ExprCaseClause = Core.Name "hydra.go.syntax.ExprCaseClause"
+
+_ExprCaseClause_case = Core.Name "case"
+
+_ExprCaseClause_statements = Core.Name "statements"
+
+data TypeSwitchStmt =
+  TypeSwitchStmt {
+    typeSwitchStmtInit :: (Maybe SimpleStmt),
+    typeSwitchStmtGuard :: TypeSwitchGuard,
+    typeSwitchStmtCases :: [TypeCaseClause]}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeSwitchStmt = Core.Name "hydra.go.syntax.TypeSwitchStmt"
+
+_TypeSwitchStmt_init = Core.Name "init"
+
+_TypeSwitchStmt_guard = Core.Name "guard"
+
+_TypeSwitchStmt_cases = Core.Name "cases"
+
+data TypeSwitchGuard =
+  TypeSwitchGuard {
+    typeSwitchGuardName :: (Maybe Identifier),
+    typeSwitchGuardExpression :: PrimaryExpr}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeSwitchGuard = Core.Name "hydra.go.syntax.TypeSwitchGuard"
+
+_TypeSwitchGuard_name = Core.Name "name"
+
+_TypeSwitchGuard_expression = Core.Name "expression"
+
+data TypeCaseClause =
+  TypeCaseClause {
+    typeCaseClauseCase :: (Maybe [Type]),
+    typeCaseClauseStatements :: [Statement]}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeCaseClause = Core.Name "hydra.go.syntax.TypeCaseClause"
+
+_TypeCaseClause_case = Core.Name "case"
+
+_TypeCaseClause_statements = Core.Name "statements"
+
+data ForStmt =
+  ForStmt {
+    forStmtClause :: (Maybe ForClauseOrRange),
+    forStmtBody :: Block}
+  deriving (Eq, Ord, Read, Show)
+
+_ForStmt = Core.Name "hydra.go.syntax.ForStmt"
+
+_ForStmt_clause = Core.Name "clause"
+
+_ForStmt_body = Core.Name "body"
+
+data ForClauseOrRange =
+  ForClauseOrRangeCondition Expression |
+  ForClauseOrRangeClause ForClause |
+  ForClauseOrRangeRange RangeClause
+  deriving (Eq, Ord, Read, Show)
+
+_ForClauseOrRange = Core.Name "hydra.go.syntax.ForClauseOrRange"
+
+_ForClauseOrRange_condition = Core.Name "condition"
+
+_ForClauseOrRange_clause = Core.Name "clause"
+
+_ForClauseOrRange_range = Core.Name "range"
+
+data ForClause =
+  ForClause {
+    forClauseInit :: (Maybe SimpleStmt),
+    forClauseCondition :: (Maybe Expression),
+    forClausePost :: (Maybe SimpleStmt)}
+  deriving (Eq, Ord, Read, Show)
+
+_ForClause = Core.Name "hydra.go.syntax.ForClause"
+
+_ForClause_init = Core.Name "init"
+
+_ForClause_condition = Core.Name "condition"
+
+_ForClause_post = Core.Name "post"
+
+data RangeClause =
+  RangeClause {
+    rangeClauseVars :: (Maybe RangeVars),
+    rangeClauseExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_RangeClause = Core.Name "hydra.go.syntax.RangeClause"
+
+_RangeClause_vars = Core.Name "vars"
+
+_RangeClause_expression = Core.Name "expression"
+
+data RangeVars =
+  RangeVarsAssign [Expression] |
+  RangeVarsDeclare [Identifier]
+  deriving (Eq, Ord, Read, Show)
+
+_RangeVars = Core.Name "hydra.go.syntax.RangeVars"
+
+_RangeVars_assign = Core.Name "assign"
+
+_RangeVars_declare = Core.Name "declare"
+
+newtype GoStmt =
+  GoStmt {
+    unGoStmt :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_GoStmt = Core.Name "hydra.go.syntax.GoStmt"
+
+newtype SelectStmt =
+  SelectStmt {
+    unSelectStmt :: [CommClause]}
+  deriving (Eq, Ord, Read, Show)
+
+_SelectStmt = Core.Name "hydra.go.syntax.SelectStmt"
+
+data CommClause =
+  CommClause {
+    commClauseCase :: CommCase,
+    commClauseStatements :: [Statement]}
+  deriving (Eq, Ord, Read, Show)
+
+_CommClause = Core.Name "hydra.go.syntax.CommClause"
+
+_CommClause_case = Core.Name "case"
+
+_CommClause_statements = Core.Name "statements"
+
+data CommCase =
+  CommCaseSend SendStmt |
+  CommCaseReceive ReceiveCase |
+  CommCaseDefault
+  deriving (Eq, Ord, Read, Show)
+
+_CommCase = Core.Name "hydra.go.syntax.CommCase"
+
+_CommCase_send = Core.Name "send"
+
+_CommCase_receive = Core.Name "receive"
+
+_CommCase_default = Core.Name "default"
+
+data ReceiveCase =
+  ReceiveCase {
+    receiveCaseVars :: (Maybe RangeVars),
+    receiveCaseExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_ReceiveCase = Core.Name "hydra.go.syntax.ReceiveCase"
+
+_ReceiveCase_vars = Core.Name "vars"
+
+_ReceiveCase_expression = Core.Name "expression"
+
+newtype ReturnStmt =
+  ReturnStmt {
+    unReturnStmt :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_ReturnStmt = Core.Name "hydra.go.syntax.ReturnStmt"
+
+newtype BreakStmt =
+  BreakStmt {
+    unBreakStmt :: (Maybe Identifier)}
+  deriving (Eq, Ord, Read, Show)
+
+_BreakStmt = Core.Name "hydra.go.syntax.BreakStmt"
+
+newtype ContinueStmt =
+  ContinueStmt {
+    unContinueStmt :: (Maybe Identifier)}
+  deriving (Eq, Ord, Read, Show)
+
+_ContinueStmt = Core.Name "hydra.go.syntax.ContinueStmt"
+
+newtype GotoStmt =
+  GotoStmt {
+    unGotoStmt :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_GotoStmt = Core.Name "hydra.go.syntax.GotoStmt"
+
+newtype FallthroughStmt =
+  FallthroughStmt {
+    unFallthroughStmt :: ()}
+  deriving (Eq, Ord, Read, Show)
+
+_FallthroughStmt = Core.Name "hydra.go.syntax.FallthroughStmt"
+
+newtype DeferStmt =
+  DeferStmt {
+    unDeferStmt :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_DeferStmt = Core.Name "hydra.go.syntax.DeferStmt"
+
+newtype Block =
+  Block {
+    unBlock :: [Statement]}
+  deriving (Eq, Ord, Read, Show)
+
+_Block = Core.Name "hydra.go.syntax.Block"
+
+data UnaryOp =
+  UnaryOpPlus |
+  UnaryOpMinus |
+  UnaryOpNot |
+  UnaryOpXor |
+  UnaryOpDeref |
+  UnaryOpAddressOf |
+  UnaryOpReceive
+  deriving (Eq, Ord, Read, Show)
+
+_UnaryOp = Core.Name "hydra.go.syntax.UnaryOp"
+
+_UnaryOp_plus = Core.Name "plus"
+
+_UnaryOp_minus = Core.Name "minus"
+
+_UnaryOp_not = Core.Name "not"
+
+_UnaryOp_xor = Core.Name "xor"
+
+_UnaryOp_deref = Core.Name "deref"
+
+_UnaryOp_addressOf = Core.Name "addressOf"
+
+_UnaryOp_receive = Core.Name "receive"
+
+data MulOp =
+  MulOpMultiply |
+  MulOpDivide |
+  MulOpRemainder |
+  MulOpLeftShift |
+  MulOpRightShift |
+  MulOpBitwiseAnd |
+  MulOpBitClear
+  deriving (Eq, Ord, Read, Show)
+
+_MulOp = Core.Name "hydra.go.syntax.MulOp"
+
+_MulOp_multiply = Core.Name "multiply"
+
+_MulOp_divide = Core.Name "divide"
+
+_MulOp_remainder = Core.Name "remainder"
+
+_MulOp_leftShift = Core.Name "leftShift"
+
+_MulOp_rightShift = Core.Name "rightShift"
+
+_MulOp_bitwiseAnd = Core.Name "bitwiseAnd"
+
+_MulOp_bitClear = Core.Name "bitClear"
+
+data AddOp =
+  AddOpAdd |
+  AddOpSubtract |
+  AddOpBitwiseOr |
+  AddOpBitwiseXor
+  deriving (Eq, Ord, Read, Show)
+
+_AddOp = Core.Name "hydra.go.syntax.AddOp"
+
+_AddOp_add = Core.Name "add"
+
+_AddOp_subtract = Core.Name "subtract"
+
+_AddOp_bitwiseOr = Core.Name "bitwiseOr"
+
+_AddOp_bitwiseXor = Core.Name "bitwiseXor"
+
+data RelOp =
+  RelOpEqual |
+  RelOpNotEqual |
+  RelOpLess |
+  RelOpLessEqual |
+  RelOpGreater |
+  RelOpGreaterEqual
+  deriving (Eq, Ord, Read, Show)
+
+_RelOp = Core.Name "hydra.go.syntax.RelOp"
+
+_RelOp_equal = Core.Name "equal"
+
+_RelOp_notEqual = Core.Name "notEqual"
+
+_RelOp_less = Core.Name "less"
+
+_RelOp_lessEqual = Core.Name "lessEqual"
+
+_RelOp_greater = Core.Name "greater"
+
+_RelOp_greaterEqual = Core.Name "greaterEqual"