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-java.cabal b/hydra-java.cabal
new file mode 100644
--- /dev/null
+++ b/hydra-java.cabal
@@ -0,0 +1,53 @@
+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-java
+version:        0.17.0
+synopsis:       Hydra's Java coder: emit Java 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". Java 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.Decode.Gradle
+      Hydra.Dsl.Java.Environment
+      Hydra.Dsl.Java.Syntax
+      Hydra.Encode.Gradle
+      Hydra.Gradle
+      Hydra.Java.Coder
+      Hydra.Java.Environment
+      Hydra.Java.Language
+      Hydra.Java.Names
+      Hydra.Java.Serde
+      Hydra.Java.Syntax
+      Hydra.Java.Testing
+      Hydra.Java.Utils
+  other-modules:
+      Paths_hydra_java
+  hs-source-dirs:
+      src/main/haskell
+  build-depends:
+      base >=4.19.0 && <4.22
+    , containers >=0.6.7 && <0.8
+    , hydra-jvm ==0.17.0
+    , hydra-kernel ==0.17.0
+    , scientific >=0.3.7 && <0.4
+  default-language: Haskell2010
diff --git a/src/main/haskell/Hydra/Decode/Gradle.hs b/src/main/haskell/Hydra/Decode/Gradle.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Decode/Gradle.hs
@@ -0,0 +1,56 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Term decoders for hydra.gradle
+
+module Hydra.Decode.Gradle where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.Decode.File as File
+import qualified Hydra.Decode.Packaging as Packaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Extract.Core as ExtractCore
+import qualified Hydra.Gradle as Gradle
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Lexical as Lexical
+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers
+import qualified Hydra.Rewriting as Rewriting
+import qualified Hydra.Util as Util
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+-- | Decoder for hydra.gradle.AntlrConfig
+antlrConfig :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Gradle.AntlrConfig
+antlrConfig cx raw =
+    Eithers.either (\err -> Left err) (\stripped -> case stripped of
+      Core.TermRecord v0 ->
+        let fieldMap = ExtractCore.toFieldMap v0
+        in (Eithers.bind (ExtractCore.requireField "arguments" (ExtractCore.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of
+          Core.TermLiteral v1 -> case v1 of
+            Core.LiteralString v2 -> Right v2
+            _ -> Left (Errors.DecodingError "expected string literal")
+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_arguments -> Eithers.bind (ExtractCore.requireField "outputDirectory" File.filePath fieldMap cx) (\field_outputDirectory -> Right (Gradle.AntlrConfig {
+          Gradle.antlrConfigArguments = field_arguments,
+          Gradle.antlrConfigOutputDirectory = field_outputDirectory}))))
+      _ -> Left (Errors.DecodingError "expected a record of type hydra.gradle.AntlrConfig")) (ExtractCore.stripWithDecodingError cx raw)
+
+-- | Decoder for hydra.gradle.GradleBuildConfiguration
+gradleBuildConfiguration :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Gradle.GradleBuildConfiguration
+gradleBuildConfiguration cx raw =
+    Eithers.either (\err -> Left err) (\stripped -> case stripped of
+      Core.TermRecord v0 ->
+        let fieldMap = ExtractCore.toFieldMap v0
+        in (Eithers.bind (ExtractCore.requireField "dependencies" (ExtractCore.decodeList Packaging.packageDependency) fieldMap cx) (\field_dependencies -> Eithers.bind (ExtractCore.requireField "excludes" (ExtractCore.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of
+          Core.TermLiteral v1 -> case v1 of
+            Core.LiteralString v2 -> Right v2
+            _ -> Left (Errors.DecodingError "expected string literal")
+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_excludes -> Eithers.bind (ExtractCore.requireField "extraSourceDirs" (ExtractCore.decodeList File.filePath) fieldMap cx) (\field_extraSourceDirs -> Eithers.bind (ExtractCore.requireField "plugins" (ExtractCore.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of
+          Core.TermLiteral v1 -> case v1 of
+            Core.LiteralString v2 -> Right v2
+            _ -> Left (Errors.DecodingError "expected string literal")
+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_plugins -> Eithers.bind (ExtractCore.requireField "antlr" (ExtractCore.decodeMaybe antlrConfig) fieldMap cx) (\field_antlr -> Right (Gradle.GradleBuildConfiguration {
+          Gradle.gradleBuildConfigurationDependencies = field_dependencies,
+          Gradle.gradleBuildConfigurationExcludes = field_excludes,
+          Gradle.gradleBuildConfigurationExtraSourceDirs = field_extraSourceDirs,
+          Gradle.gradleBuildConfigurationPlugins = field_plugins,
+          Gradle.gradleBuildConfigurationAntlr = field_antlr})))))))
+      _ -> Left (Errors.DecodingError "expected a record of type hydra.gradle.GradleBuildConfiguration")) (ExtractCore.stripWithDecodingError cx raw)
diff --git a/src/main/haskell/Hydra/Dsl/Java/Environment.hs b/src/main/haskell/Hydra/Dsl/Java/Environment.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Dsl/Java/Environment.hs
@@ -0,0 +1,1546 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | DSL functions for hydra.java.environment
+
+module Hydra.Dsl.Java.Environment where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.Dsl.Core as DslCore
+import qualified Hydra.Dsl.Graph as DslGraph
+import qualified Hydra.Dsl.Java.Syntax as JavaSyntax
+import qualified Hydra.Dsl.Packaging as DslPackaging
+import qualified Hydra.Dsl.Typing as DslTyping
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Java.Environment as Environment
+import qualified Hydra.Java.Syntax as Syntax
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Map as M
+import qualified Data.Set as S
+
+-- | DSL constructor for hydra.java.environment.Aliases
+aliases :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm (M.Map Packaging.ModuleName Syntax.PackageName) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (M.Map Core.Name Core.Name) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (M.Map Core.Name Core.Name) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliases currentNamespace packages branchVars recursiveVars inScopeTypeParams polymorphicLocals inScopeJavaVars varRenames lambdaVars typeVarSubst trustedTypeVars methodCodomain thunkedVars =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Typed.unTypedTerm currentNamespace)},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Typed.unTypedTerm packages)},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Typed.unTypedTerm branchVars)},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Typed.unTypedTerm recursiveVars)},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Typed.unTypedTerm inScopeTypeParams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Typed.unTypedTerm polymorphicLocals)},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Typed.unTypedTerm inScopeJavaVars)},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Typed.unTypedTerm varRenames)},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Typed.unTypedTerm lambdaVars)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Typed.unTypedTerm typeVarSubst)},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Typed.unTypedTerm trustedTypeVars)},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Typed.unTypedTerm methodCodomain)},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Typed.unTypedTerm thunkedVars)}]}))
+
+-- | DSL accessor for the branchVars field of hydra.java.environment.Aliases
+aliasesBranchVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name)
+aliasesBranchVars x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "branchVars")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the currentNamespace field of hydra.java.environment.Aliases
+aliasesCurrentNamespace :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm Packaging.ModuleName
+aliasesCurrentNamespace x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "currentNamespace")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the inScopeJavaVars field of hydra.java.environment.Aliases
+aliasesInScopeJavaVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name)
+aliasesInScopeJavaVars x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the inScopeTypeParams field of hydra.java.environment.Aliases
+aliasesInScopeTypeParams :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name)
+aliasesInScopeTypeParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the lambdaVars field of hydra.java.environment.Aliases
+aliasesLambdaVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name)
+aliasesLambdaVars x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "lambdaVars")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the methodCodomain field of hydra.java.environment.Aliases
+aliasesMethodCodomain :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (Maybe Core.Type)
+aliasesMethodCodomain x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "methodCodomain")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the packages field of hydra.java.environment.Aliases
+aliasesPackages :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (M.Map Packaging.ModuleName Syntax.PackageName)
+aliasesPackages x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "packages")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the polymorphicLocals field of hydra.java.environment.Aliases
+aliasesPolymorphicLocals :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name)
+aliasesPolymorphicLocals x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the recursiveVars field of hydra.java.environment.Aliases
+aliasesRecursiveVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name)
+aliasesRecursiveVars x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "recursiveVars")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the thunkedVars field of hydra.java.environment.Aliases
+aliasesThunkedVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name)
+aliasesThunkedVars x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "thunkedVars")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the trustedTypeVars field of hydra.java.environment.Aliases
+aliasesTrustedTypeVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name)
+aliasesTrustedTypeVars x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeVarSubst field of hydra.java.environment.Aliases
+aliasesTypeVarSubst :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (M.Map Core.Name Core.Name)
+aliasesTypeVarSubst x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the varRenames field of hydra.java.environment.Aliases
+aliasesVarRenames :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (M.Map Core.Name Core.Name)
+aliasesVarRenames x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+        Core.projectionFieldName = (Core.Name "varRenames")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the branchVars field of hydra.java.environment.Aliases
+aliasesWithBranchVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithBranchVars original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the currentNamespace field of hydra.java.environment.Aliases
+aliasesWithCurrentNamespace :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Environment.Aliases
+aliasesWithCurrentNamespace original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the inScopeJavaVars field of hydra.java.environment.Aliases
+aliasesWithInScopeJavaVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithInScopeJavaVars original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the inScopeTypeParams field of hydra.java.environment.Aliases
+aliasesWithInScopeTypeParams :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithInScopeTypeParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the lambdaVars field of hydra.java.environment.Aliases
+aliasesWithLambdaVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithLambdaVars original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the methodCodomain field of hydra.java.environment.Aliases
+aliasesWithMethodCodomain :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm Environment.Aliases
+aliasesWithMethodCodomain original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the packages field of hydra.java.environment.Aliases
+aliasesWithPackages :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (M.Map Packaging.ModuleName Syntax.PackageName) -> Typed.TypedTerm Environment.Aliases
+aliasesWithPackages original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the polymorphicLocals field of hydra.java.environment.Aliases
+aliasesWithPolymorphicLocals :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithPolymorphicLocals original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the recursiveVars field of hydra.java.environment.Aliases
+aliasesWithRecursiveVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithRecursiveVars original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the thunkedVars field of hydra.java.environment.Aliases
+aliasesWithThunkedVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithThunkedVars original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the trustedTypeVars field of hydra.java.environment.Aliases
+aliasesWithTrustedTypeVars :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithTrustedTypeVars original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeVarSubst field of hydra.java.environment.Aliases
+aliasesWithTypeVarSubst :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (M.Map Core.Name Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithTypeVarSubst original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "varRenames")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the varRenames field of hydra.java.environment.Aliases
+aliasesWithVarRenames :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm (M.Map Core.Name Core.Name) -> Typed.TypedTerm Environment.Aliases
+aliasesWithVarRenames original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.Aliases"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "currentNamespace"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "currentNamespace")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "packages"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "packages")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "branchVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "branchVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "recursiveVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "recursiveVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeTypeParams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeTypeParams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "polymorphicLocals"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "polymorphicLocals")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inScopeJavaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "inScopeJavaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "varRenames"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "lambdaVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "lambdaVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeVarSubst"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "typeVarSubst")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trustedTypeVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "trustedTypeVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "methodCodomain"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "methodCodomain")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thunkedVars"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.Aliases"),
+              Core.projectionFieldName = (Core.Name "thunkedVars")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.environment.JavaEnvironment
+javaEnvironment :: Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.JavaEnvironment
+javaEnvironment aliases graph =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.JavaEnvironment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "aliases"),
+          Core.fieldTerm = (Typed.unTypedTerm aliases)},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Typed.unTypedTerm graph)}]}))
+
+-- | DSL accessor for the aliases field of hydra.java.environment.JavaEnvironment
+javaEnvironmentAliases :: Typed.TypedTerm Environment.JavaEnvironment -> Typed.TypedTerm Environment.Aliases
+javaEnvironmentAliases x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.JavaEnvironment"),
+        Core.projectionFieldName = (Core.Name "aliases")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the graph field of hydra.java.environment.JavaEnvironment
+javaEnvironmentGraph :: Typed.TypedTerm Environment.JavaEnvironment -> Typed.TypedTerm Graph.Graph
+javaEnvironmentGraph x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.JavaEnvironment"),
+        Core.projectionFieldName = (Core.Name "graph")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the aliases field of hydra.java.environment.JavaEnvironment
+javaEnvironmentWithAliases :: Typed.TypedTerm Environment.JavaEnvironment -> Typed.TypedTerm Environment.Aliases -> Typed.TypedTerm Environment.JavaEnvironment
+javaEnvironmentWithAliases original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.JavaEnvironment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "aliases"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.JavaEnvironment"),
+              Core.projectionFieldName = (Core.Name "graph")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the graph field of hydra.java.environment.JavaEnvironment
+javaEnvironmentWithGraph :: Typed.TypedTerm Environment.JavaEnvironment -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.JavaEnvironment
+javaEnvironmentWithGraph original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.JavaEnvironment"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "aliases"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.environment.JavaEnvironment"),
+              Core.projectionFieldName = (Core.Name "aliases")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "graph"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.environment.JavaFeatures
+javaFeatures :: Typed.TypedTerm Bool -> Typed.TypedTerm Environment.JavaFeatures
+javaFeatures supportsDiamondOperator =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.JavaFeatures"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "supportsDiamondOperator"),
+          Core.fieldTerm = (Typed.unTypedTerm supportsDiamondOperator)}]}))
+
+-- | DSL accessor for the supportsDiamondOperator field of hydra.java.environment.JavaFeatures
+javaFeaturesSupportsDiamondOperator :: Typed.TypedTerm Environment.JavaFeatures -> Typed.TypedTerm Bool
+javaFeaturesSupportsDiamondOperator x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.environment.JavaFeatures"),
+        Core.projectionFieldName = (Core.Name "supportsDiamondOperator")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the supportsDiamondOperator field of hydra.java.environment.JavaFeatures
+javaFeaturesWithSupportsDiamondOperator :: Typed.TypedTerm Environment.JavaFeatures -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.JavaFeatures
+javaFeaturesWithSupportsDiamondOperator original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.environment.JavaFeatures"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "supportsDiamondOperator"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the constant variant of hydra.java.environment.JavaSymbolClass
+javaSymbolClassConstant :: Typed.TypedTerm Environment.JavaSymbolClass
+javaSymbolClassConstant =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.environment.JavaSymbolClass"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "constant"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the hoistedLambda variant of hydra.java.environment.JavaSymbolClass
+javaSymbolClassHoistedLambda :: Typed.TypedTerm Int -> Typed.TypedTerm Environment.JavaSymbolClass
+javaSymbolClassHoistedLambda x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.environment.JavaSymbolClass"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "hoistedLambda"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the localVariable variant of hydra.java.environment.JavaSymbolClass
+javaSymbolClassLocalVariable :: Typed.TypedTerm Environment.JavaSymbolClass
+javaSymbolClassLocalVariable =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.environment.JavaSymbolClass"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "localVariable"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the nullaryFunction variant of hydra.java.environment.JavaSymbolClass
+javaSymbolClassNullaryFunction :: Typed.TypedTerm Environment.JavaSymbolClass
+javaSymbolClassNullaryFunction =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.environment.JavaSymbolClass"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "nullaryFunction"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the unaryFunction variant of hydra.java.environment.JavaSymbolClass
+javaSymbolClassUnaryFunction :: Typed.TypedTerm Environment.JavaSymbolClass
+javaSymbolClassUnaryFunction =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.environment.JavaSymbolClass"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unaryFunction"),
+        Core.fieldTerm = Core.TermUnit}}))
diff --git a/src/main/haskell/Hydra/Dsl/Java/Syntax.hs b/src/main/haskell/Hydra/Dsl/Java/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Dsl/Java/Syntax.hs
@@ -0,0 +1,15718 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | DSL functions for hydra.java.syntax
+
+module Hydra.Dsl.Java.Syntax where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.Dsl.Core as DslCore
+import qualified Hydra.Java.Syntax as Syntax
+import qualified Hydra.Typed as Typed
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+-- | DSL constructor for the hydra.java.syntax.AdditionalBound wrapper
+additionalBound :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.AdditionalBound
+additionalBound x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.AdditionalBound"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the minus variant of hydra.java.syntax.AdditiveExpression
+additiveExpressionMinus :: Typed.TypedTerm Syntax.AdditiveExpression_Binary -> Typed.TypedTerm Syntax.AdditiveExpression
+additiveExpressionMinus x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AdditiveExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "minus"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the plus variant of hydra.java.syntax.AdditiveExpression
+additiveExpressionPlus :: Typed.TypedTerm Syntax.AdditiveExpression_Binary -> Typed.TypedTerm Syntax.AdditiveExpression
+additiveExpressionPlus x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AdditiveExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "plus"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the unary variant of hydra.java.syntax.AdditiveExpression
+additiveExpressionUnary :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AdditiveExpression
+additiveExpressionUnary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AdditiveExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.AdditiveExpression_Binary
+additiveExpression_Binary :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AdditiveExpression_Binary
+additiveExpression_Binary lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AdditiveExpression_Binary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.AdditiveExpression_Binary
+additiveExpression_BinaryLhs :: Typed.TypedTerm Syntax.AdditiveExpression_Binary -> Typed.TypedTerm Syntax.AdditiveExpression
+additiveExpression_BinaryLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AdditiveExpression_Binary"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.AdditiveExpression_Binary
+additiveExpression_BinaryRhs :: Typed.TypedTerm Syntax.AdditiveExpression_Binary -> Typed.TypedTerm Syntax.MultiplicativeExpression
+additiveExpression_BinaryRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AdditiveExpression_Binary"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.AdditiveExpression_Binary
+additiveExpression_BinaryWithLhs :: Typed.TypedTerm Syntax.AdditiveExpression_Binary -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.AdditiveExpression_Binary
+additiveExpression_BinaryWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AdditiveExpression_Binary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.AdditiveExpression_Binary"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.AdditiveExpression_Binary
+additiveExpression_BinaryWithRhs :: Typed.TypedTerm Syntax.AdditiveExpression_Binary -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AdditiveExpression_Binary
+additiveExpression_BinaryWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AdditiveExpression_Binary"),
+      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.java.syntax.AdditiveExpression_Binary"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.java.syntax.AmbiguousName wrapper
+ambiguousName :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.AmbiguousName
+ambiguousName x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.AmbiguousName"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.AndExpression wrapper
+andExpression :: Typed.TypedTerm [Syntax.EqualityExpression] -> Typed.TypedTerm Syntax.AndExpression
+andExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.AndExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.AnnotatedIdentifier
+annotatedIdentifier :: Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AnnotatedIdentifier
+annotatedIdentifier annotations identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotatedIdentifier"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.AnnotatedIdentifier
+annotatedIdentifierAnnotations :: Typed.TypedTerm Syntax.AnnotatedIdentifier -> Typed.TypedTerm [Syntax.Annotation]
+annotatedIdentifierAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotatedIdentifier"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.AnnotatedIdentifier
+annotatedIdentifierIdentifier :: Typed.TypedTerm Syntax.AnnotatedIdentifier -> Typed.TypedTerm Syntax.Identifier
+annotatedIdentifierIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotatedIdentifier"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.AnnotatedIdentifier
+annotatedIdentifierWithAnnotations :: Typed.TypedTerm Syntax.AnnotatedIdentifier -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.AnnotatedIdentifier
+annotatedIdentifierWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotatedIdentifier"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotatedIdentifier"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.AnnotatedIdentifier
+annotatedIdentifierWithIdentifier :: Typed.TypedTerm Syntax.AnnotatedIdentifier -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AnnotatedIdentifier
+annotatedIdentifierWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotatedIdentifier"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotatedIdentifier"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.java.syntax.AnnotationInterfaceBody wrapper
+annotationInterfaceBody :: Typed.TypedTerm [Syntax.AnnotationInterfaceMemberDeclaration] -> Typed.TypedTerm Syntax.AnnotationInterfaceBody
+annotationInterfaceBody x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceBody"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclaration :: Typed.TypedTerm [Syntax.InterfaceModifier] -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.AnnotationInterfaceBody -> Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclaration modifiers identifier body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationBody :: Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration -> Typed.TypedTerm Syntax.AnnotationInterfaceBody
+annotationInterfaceDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationIdentifier :: Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier
+annotationInterfaceDeclarationIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationModifiers :: Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceModifier]
+annotationInterfaceDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationWithBody :: Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration -> Typed.TypedTerm Syntax.AnnotationInterfaceBody -> Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationWithIdentifier :: Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          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.java.syntax.AnnotationInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationWithModifiers :: Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceModifier] -> Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration
+annotationInterfaceDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            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.java.syntax.AnnotationInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclaration :: Typed.TypedTerm [Syntax.AnnotationInterfaceElementModifier] -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.Dims) -> Typed.TypedTerm (Maybe Syntax.DefaultValue) -> Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclaration modifiers type_ identifier dims default_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm dims)},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))
+
+-- | DSL accessor for the default field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationDefault :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm (Maybe Syntax.DefaultValue)
+annotationInterfaceElementDeclarationDefault x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+        Core.projectionFieldName = (Core.Name "default")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the dims field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationDims :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm (Maybe Syntax.Dims)
+annotationInterfaceElementDeclarationDims x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+        Core.projectionFieldName = (Core.Name "dims")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationIdentifier :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm Syntax.Identifier
+annotationInterfaceElementDeclarationIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationModifiers :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm [Syntax.AnnotationInterfaceElementModifier]
+annotationInterfaceElementDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationType :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm Syntax.UnannType
+annotationInterfaceElementDeclarationType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the default field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithDefault :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm (Maybe Syntax.DefaultValue) -> Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithDefault original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the dims field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithDims :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm (Maybe Syntax.Dims) -> Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithDims original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithIdentifier :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithModifiers :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm [Syntax.AnnotationInterfaceElementModifier] -> Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithType :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration
+annotationInterfaceElementDeclarationWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the abstract variant of hydra.java.syntax.AnnotationInterfaceElementModifier
+annotationInterfaceElementModifierAbstract :: Typed.TypedTerm Syntax.AnnotationInterfaceElementModifier
+annotationInterfaceElementModifierAbstract =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "abstract"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.AnnotationInterfaceElementModifier
+annotationInterfaceElementModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.AnnotationInterfaceElementModifier
+annotationInterfaceElementModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the public variant of hydra.java.syntax.AnnotationInterfaceElementModifier
+annotationInterfaceElementModifierPublic :: Typed.TypedTerm Syntax.AnnotationInterfaceElementModifier
+annotationInterfaceElementModifierPublic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceElementModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "public"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the annotationInterface variant of hydra.java.syntax.AnnotationInterfaceMemberDeclaration
+annotationInterfaceMemberDeclarationAnnotationInterface :: Typed.TypedTerm Syntax.AnnotationInterfaceElementDeclaration -> Typed.TypedTerm Syntax.AnnotationInterfaceMemberDeclaration
+annotationInterfaceMemberDeclarationAnnotationInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotationInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the class variant of hydra.java.syntax.AnnotationInterfaceMemberDeclaration
+annotationInterfaceMemberDeclarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.AnnotationInterfaceMemberDeclaration
+annotationInterfaceMemberDeclarationClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the constant variant of hydra.java.syntax.AnnotationInterfaceMemberDeclaration
+annotationInterfaceMemberDeclarationConstant :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.AnnotationInterfaceMemberDeclaration
+annotationInterfaceMemberDeclarationConstant x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "constant"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interface variant of hydra.java.syntax.AnnotationInterfaceMemberDeclaration
+annotationInterfaceMemberDeclarationInterface :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.AnnotationInterfaceMemberDeclaration
+annotationInterfaceMemberDeclarationInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AnnotationInterfaceMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the marker variant of hydra.java.syntax.Annotation
+annotationMarker :: Typed.TypedTerm Syntax.MarkerAnnotation -> Typed.TypedTerm Syntax.Annotation
+annotationMarker x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Annotation"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "marker"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the normal variant of hydra.java.syntax.Annotation
+annotationNormal :: Typed.TypedTerm Syntax.NormalAnnotation -> Typed.TypedTerm Syntax.Annotation
+annotationNormal x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Annotation"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "normal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the singleElement variant of hydra.java.syntax.Annotation
+annotationSingleElement :: Typed.TypedTerm Syntax.SingleElementAnnotation -> Typed.TypedTerm Syntax.Annotation
+annotationSingleElement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Annotation"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "singleElement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ArrayAccess
+arrayAccess :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.ArrayAccess_Variant -> Typed.TypedTerm Syntax.ArrayAccess
+arrayAccess expression variant =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Typed.unTypedTerm variant)}]}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.ArrayAccess
+arrayAccessExpression :: Typed.TypedTerm Syntax.ArrayAccess -> Typed.TypedTerm (Maybe Syntax.Expression)
+arrayAccessExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayAccess"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the variant field of hydra.java.syntax.ArrayAccess
+arrayAccessVariant :: Typed.TypedTerm Syntax.ArrayAccess -> Typed.TypedTerm Syntax.ArrayAccess_Variant
+arrayAccessVariant x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayAccess"),
+        Core.projectionFieldName = (Core.Name "variant")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.ArrayAccess
+arrayAccessWithExpression :: Typed.TypedTerm Syntax.ArrayAccess -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.ArrayAccess
+arrayAccessWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayAccess"),
+              Core.projectionFieldName = (Core.Name "variant")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the variant field of hydra.java.syntax.ArrayAccess
+arrayAccessWithVariant :: Typed.TypedTerm Syntax.ArrayAccess -> Typed.TypedTerm Syntax.ArrayAccess_Variant -> Typed.TypedTerm Syntax.ArrayAccess
+arrayAccessWithVariant original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayAccess"),
+      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.java.syntax.ArrayAccess"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the arrayCreationWithInitializer variant of hydra.java.syntax.ArrayAccess_Variant
+arrayAccess_VariantArrayCreationWithInitializer :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer -> Typed.TypedTerm Syntax.ArrayAccess_Variant
+arrayAccess_VariantArrayCreationWithInitializer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayAccess_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "arrayCreationWithInitializer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the name variant of hydra.java.syntax.ArrayAccess_Variant
+arrayAccess_VariantName :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.ArrayAccess_Variant
+arrayAccess_VariantName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayAccess_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primary variant of hydra.java.syntax.ArrayAccess_Variant
+arrayAccess_VariantPrimary :: Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression -> Typed.TypedTerm Syntax.ArrayAccess_Variant
+arrayAccess_VariantPrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayAccess_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the withInitializer variant of hydra.java.syntax.ArrayCreationExpression
+arrayCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer -> Typed.TypedTerm Syntax.ArrayCreationExpression
+arrayCreationExpressionWithInitializer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "withInitializer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the classOrInterface variant of hydra.java.syntax.ArrayCreationExpressionWithInitializer
+arrayCreationExpressionWithInitializerClassOrInterface :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer
+arrayCreationExpressionWithInitializerClassOrInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classOrInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primitive variant of hydra.java.syntax.ArrayCreationExpressionWithInitializer
+arrayCreationExpressionWithInitializerPrimitive :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer
+arrayCreationExpressionWithInitializerPrimitive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primitive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterface :: Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm [Syntax.Dims] -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterface type_ dims array =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm dims)},
+        Core.Field {
+          Core.fieldName = (Core.Name "array"),
+          Core.fieldTerm = (Typed.unTypedTerm array)}]}))
+
+-- | DSL accessor for the array field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceArray :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface -> Typed.TypedTerm Syntax.ArrayInitializer
+arrayCreationExpressionWithInitializer_ClassOrInterfaceArray x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+        Core.projectionFieldName = (Core.Name "array")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the dims field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceDims :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface -> Typed.TypedTerm [Syntax.Dims]
+arrayCreationExpressionWithInitializer_ClassOrInterfaceDims x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+        Core.projectionFieldName = (Core.Name "dims")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceType :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface -> Typed.TypedTerm Syntax.ClassOrInterfaceType
+arrayCreationExpressionWithInitializer_ClassOrInterfaceType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the array field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceWithArray :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceWithArray original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+      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.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "array"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the dims field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceWithDims :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface -> Typed.TypedTerm [Syntax.Dims] -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceWithDims original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+      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.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "array"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "array")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceWithType :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface -> Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface
+arrayCreationExpressionWithInitializer_ClassOrInterfaceWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "array"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "array")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_Primitive :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm [Syntax.Dims] -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_Primitive type_ dims array =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm dims)},
+        Core.Field {
+          Core.fieldName = (Core.Name "array"),
+          Core.fieldTerm = (Typed.unTypedTerm array)}]}))
+
+-- | DSL accessor for the array field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveArray :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive -> Typed.TypedTerm Syntax.ArrayInitializer
+arrayCreationExpressionWithInitializer_PrimitiveArray x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+        Core.projectionFieldName = (Core.Name "array")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the dims field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveDims :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive -> Typed.TypedTerm [Syntax.Dims]
+arrayCreationExpressionWithInitializer_PrimitiveDims x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+        Core.projectionFieldName = (Core.Name "dims")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveType :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations
+arrayCreationExpressionWithInitializer_PrimitiveType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the array field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveWithArray :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveWithArray original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+      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.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "array"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the dims field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveWithDims :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive -> Typed.TypedTerm [Syntax.Dims] -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveWithDims original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+      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.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "array"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "array")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveWithType :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithInitializer_Primitive
+arrayCreationExpressionWithInitializer_PrimitiveWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "array"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "array")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the withoutInitializer variant of hydra.java.syntax.ArrayCreationExpression
+arrayCreationExpressionWithoutInitializer :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer -> Typed.TypedTerm Syntax.ArrayCreationExpression
+arrayCreationExpressionWithoutInitializer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "withoutInitializer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the classOrInterface variant of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer
+arrayCreationExpressionWithoutInitializerClassOrInterface :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer
+arrayCreationExpressionWithoutInitializerClassOrInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classOrInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primitive variant of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer
+arrayCreationExpressionWithoutInitializerPrimitive :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer
+arrayCreationExpressionWithoutInitializerPrimitive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primitive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterface :: Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm [Syntax.DimExpr] -> Typed.TypedTerm (Maybe Syntax.Dims) -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterface type_ dimExprs dims =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dimExprs"),
+          Core.fieldTerm = (Typed.unTypedTerm dimExprs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm dims)}]}))
+
+-- | DSL accessor for the dimExprs field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceDimExprs :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface -> Typed.TypedTerm [Syntax.DimExpr]
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceDimExprs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+        Core.projectionFieldName = (Core.Name "dimExprs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the dims field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceDims :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface -> Typed.TypedTerm (Maybe Syntax.Dims)
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceDims x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+        Core.projectionFieldName = (Core.Name "dims")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceType :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface -> Typed.TypedTerm Syntax.ClassOrInterfaceType
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the dimExprs field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceWithDimExprs :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface -> Typed.TypedTerm [Syntax.DimExpr] -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceWithDimExprs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+      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.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dimExprs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the dims field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceWithDims :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface -> Typed.TypedTerm (Maybe Syntax.Dims) -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceWithDims original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+      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.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dimExprs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "dimExprs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceWithType :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface -> Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+arrayCreationExpressionWithoutInitializer_ClassOrInterfaceWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dimExprs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "dimExprs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_Primitive :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm [Syntax.DimExpr] -> Typed.TypedTerm (Maybe Syntax.Dims) -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_Primitive type_ dimExprs dims =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dimExprs"),
+          Core.fieldTerm = (Typed.unTypedTerm dimExprs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm dims)}]}))
+
+-- | DSL accessor for the dimExprs field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveDimExprs :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive -> Typed.TypedTerm [Syntax.DimExpr]
+arrayCreationExpressionWithoutInitializer_PrimitiveDimExprs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+        Core.projectionFieldName = (Core.Name "dimExprs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the dims field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveDims :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive -> Typed.TypedTerm (Maybe Syntax.Dims)
+arrayCreationExpressionWithoutInitializer_PrimitiveDims x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+        Core.projectionFieldName = (Core.Name "dims")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveType :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations
+arrayCreationExpressionWithoutInitializer_PrimitiveType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the dimExprs field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveWithDimExprs :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive -> Typed.TypedTerm [Syntax.DimExpr] -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveWithDimExprs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+      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.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dimExprs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the dims field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveWithDims :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive -> Typed.TypedTerm (Maybe Syntax.Dims) -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveWithDims original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+      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.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dimExprs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "dimExprs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveWithType :: Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm Syntax.ArrayCreationExpressionWithoutInitializer_Primitive
+arrayCreationExpressionWithoutInitializer_PrimitiveWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dimExprs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "dimExprs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.ArrayInitializer wrapper
+arrayInitializer :: Typed.TypedTerm [[Syntax.VariableInitializer]] -> Typed.TypedTerm Syntax.ArrayInitializer
+arrayInitializer x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ArrayInitializer"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.ArrayType
+arrayType :: Typed.TypedTerm Syntax.Dims -> Typed.TypedTerm Syntax.ArrayType_Variant -> Typed.TypedTerm Syntax.ArrayType
+arrayType dims variant =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm dims)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Typed.unTypedTerm variant)}]}))
+
+-- | DSL accessor for the dims field of hydra.java.syntax.ArrayType
+arrayTypeDims :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.Dims
+arrayTypeDims x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayType"),
+        Core.projectionFieldName = (Core.Name "dims")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the variant field of hydra.java.syntax.ArrayType
+arrayTypeVariant :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ArrayType_Variant
+arrayTypeVariant x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayType"),
+        Core.projectionFieldName = (Core.Name "variant")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the dims field of hydra.java.syntax.ArrayType
+arrayTypeWithDims :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.Dims -> Typed.TypedTerm Syntax.ArrayType
+arrayTypeWithDims original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayType"),
+              Core.projectionFieldName = (Core.Name "variant")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the variant field of hydra.java.syntax.ArrayType
+arrayTypeWithVariant :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ArrayType_Variant -> Typed.TypedTerm Syntax.ArrayType
+arrayTypeWithVariant original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ArrayType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ArrayType"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the classOrInterface variant of hydra.java.syntax.ArrayType_Variant
+arrayType_VariantClassOrInterface :: Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm Syntax.ArrayType_Variant
+arrayType_VariantClassOrInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayType_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classOrInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primitive variant of hydra.java.syntax.ArrayType_Variant
+arrayType_VariantPrimitive :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm Syntax.ArrayType_Variant
+arrayType_VariantPrimitive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayType_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primitive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variable variant of hydra.java.syntax.ArrayType_Variant
+arrayType_VariantVariable :: Typed.TypedTerm Syntax.TypeVariable -> Typed.TypedTerm Syntax.ArrayType_Variant
+arrayType_VariantVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ArrayType_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the pair variant of hydra.java.syntax.AssertStatement
+assertStatementPair :: Typed.TypedTerm Syntax.AssertStatement_Pair -> Typed.TypedTerm Syntax.AssertStatement
+assertStatementPair x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssertStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "pair"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the single variant of hydra.java.syntax.AssertStatement
+assertStatementSingle :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssertStatement
+assertStatementSingle x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssertStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "single"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.AssertStatement_Pair
+assertStatement_Pair :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssertStatement_Pair
+assertStatement_Pair first second =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AssertStatement_Pair"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "first"),
+          Core.fieldTerm = (Typed.unTypedTerm first)},
+        Core.Field {
+          Core.fieldName = (Core.Name "second"),
+          Core.fieldTerm = (Typed.unTypedTerm second)}]}))
+
+-- | DSL accessor for the first field of hydra.java.syntax.AssertStatement_Pair
+assertStatement_PairFirst :: Typed.TypedTerm Syntax.AssertStatement_Pair -> Typed.TypedTerm Syntax.Expression
+assertStatement_PairFirst x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AssertStatement_Pair"),
+        Core.projectionFieldName = (Core.Name "first")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the second field of hydra.java.syntax.AssertStatement_Pair
+assertStatement_PairSecond :: Typed.TypedTerm Syntax.AssertStatement_Pair -> Typed.TypedTerm Syntax.Expression
+assertStatement_PairSecond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.AssertStatement_Pair"),
+        Core.projectionFieldName = (Core.Name "second")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the first field of hydra.java.syntax.AssertStatement_Pair
+assertStatement_PairWithFirst :: Typed.TypedTerm Syntax.AssertStatement_Pair -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssertStatement_Pair
+assertStatement_PairWithFirst original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AssertStatement_Pair"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "first"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "second"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AssertStatement_Pair"),
+              Core.projectionFieldName = (Core.Name "second")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the second field of hydra.java.syntax.AssertStatement_Pair
+assertStatement_PairWithSecond :: Typed.TypedTerm Syntax.AssertStatement_Pair -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssertStatement_Pair
+assertStatement_PairWithSecond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.AssertStatement_Pair"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "first"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.AssertStatement_Pair"),
+              Core.projectionFieldName = (Core.Name "first")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "second"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.Assignment
+assignment :: Typed.TypedTerm Syntax.LeftHandSide -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Assignment
+assignment lhs op expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.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 "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.Assignment
+assignmentExpression :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Expression
+assignmentExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Assignment"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the assignment variant of hydra.java.syntax.AssignmentExpression
+assignmentExpressionAssignment :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignmentExpression
+assignmentExpressionAssignment x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "assignment"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the conditional variant of hydra.java.syntax.AssignmentExpression
+assignmentExpressionConditional :: Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.AssignmentExpression
+assignmentExpressionConditional x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "conditional"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.Assignment
+assignmentLhs :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.LeftHandSide
+assignmentLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Assignment"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the op field of hydra.java.syntax.Assignment
+assignmentOp :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Assignment"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the and variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorAnd :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorAnd =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "and"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the div variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorDiv :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorDiv =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "div"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the minus variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorMinus :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorMinus =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "minus"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the mod variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorMod :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorMod =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "mod"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the or variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorOr :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorOr =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "or"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the plus variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorPlus :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorPlus =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "plus"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the shiftLeft variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorShiftLeft :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorShiftLeft =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "shiftLeft"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the shiftRight variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorShiftRight :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorShiftRight =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "shiftRight"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the shiftRightZeroFill variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorShiftRightZeroFill :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorShiftRightZeroFill =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "shiftRightZeroFill"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorSimple :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorSimple =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the times variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorTimes :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorTimes =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "times"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the xor variant of hydra.java.syntax.AssignmentOperator
+assignmentOperatorXor :: Typed.TypedTerm Syntax.AssignmentOperator
+assignmentOperatorXor =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.AssignmentOperator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "xor"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.Assignment
+assignmentWithExpression :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Assignment
+assignmentWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.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.java.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.java.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.Assignment
+assignmentWithLhs :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.LeftHandSide -> Typed.TypedTerm Syntax.Assignment
+assignmentWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.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.java.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            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.java.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the op field of hydra.java.syntax.Assignment
+assignmentWithOp :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.Assignment
+assignmentWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.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.java.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 "expression"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Assignment"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.BasicForStatement
+basicForStatement :: Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.BasicForStatement
+basicForStatement cond body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.BasicForStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.BasicForStatement
+basicForStatementBody :: Typed.TypedTerm Syntax.BasicForStatement -> Typed.TypedTerm Syntax.Statement
+basicForStatementBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.BasicForStatement"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.BasicForStatement
+basicForStatementCond :: Typed.TypedTerm Syntax.BasicForStatement -> Typed.TypedTerm Syntax.ForCond
+basicForStatementCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.BasicForStatement"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.BasicForStatementNoShortIf
+basicForStatementNoShortIf :: Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.BasicForStatementNoShortIf
+basicForStatementNoShortIf cond body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.BasicForStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.BasicForStatementNoShortIf
+basicForStatementNoShortIfBody :: Typed.TypedTerm Syntax.BasicForStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+basicForStatementNoShortIfBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.BasicForStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.BasicForStatementNoShortIf
+basicForStatementNoShortIfCond :: Typed.TypedTerm Syntax.BasicForStatementNoShortIf -> Typed.TypedTerm Syntax.ForCond
+basicForStatementNoShortIfCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.BasicForStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.BasicForStatementNoShortIf
+basicForStatementNoShortIfWithBody :: Typed.TypedTerm Syntax.BasicForStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.BasicForStatementNoShortIf
+basicForStatementNoShortIfWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.BasicForStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.BasicForStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.BasicForStatementNoShortIf
+basicForStatementNoShortIfWithCond :: Typed.TypedTerm Syntax.BasicForStatementNoShortIf -> Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm Syntax.BasicForStatementNoShortIf
+basicForStatementNoShortIfWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.BasicForStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          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.java.syntax.BasicForStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the body field of hydra.java.syntax.BasicForStatement
+basicForStatementWithBody :: Typed.TypedTerm Syntax.BasicForStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.BasicForStatement
+basicForStatementWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.BasicForStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.BasicForStatement"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.BasicForStatement
+basicForStatementWithCond :: Typed.TypedTerm Syntax.BasicForStatement -> Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm Syntax.BasicForStatement
+basicForStatementWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.BasicForStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          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.java.syntax.BasicForStatement"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.Block wrapper
+block :: Typed.TypedTerm [Syntax.BlockStatement] -> Typed.TypedTerm Syntax.Block
+block x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.Block"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the localClassOrInterface variant of hydra.java.syntax.BlockStatement
+blockStatementLocalClassOrInterface :: Typed.TypedTerm Syntax.LocalClassOrInterfaceDeclaration -> Typed.TypedTerm Syntax.BlockStatement
+blockStatementLocalClassOrInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.BlockStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "localClassOrInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the localVariableDeclaration variant of hydra.java.syntax.BlockStatement
+blockStatementLocalVariableDeclaration :: Typed.TypedTerm Syntax.LocalVariableDeclarationStatement -> Typed.TypedTerm Syntax.BlockStatement
+blockStatementLocalVariableDeclaration x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.BlockStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "localVariableDeclaration"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the statement variant of hydra.java.syntax.BlockStatement
+blockStatementStatement :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.BlockStatement
+blockStatementStatement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.BlockStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "statement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the array variant of hydra.java.syntax.BooleanArray
+booleanArrayArray :: Typed.TypedTerm Syntax.BooleanArray -> Typed.TypedTerm Syntax.BooleanArray
+booleanArrayArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.BooleanArray"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "array"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.BooleanArray
+booleanArraySimple :: Typed.TypedTerm Syntax.BooleanArray
+booleanArraySimple =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.BooleanArray"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.java.syntax.BreakStatement wrapper
+breakStatement :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.BreakStatement
+breakStatement x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.BreakStatement"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.CaseConstant wrapper
+caseConstant :: Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.CaseConstant
+caseConstant x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.CaseConstant"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.CasePattern
+casePattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm (Maybe Syntax.Guard) -> Typed.TypedTerm Syntax.CasePattern
+casePattern pattern guard =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CasePattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pattern"),
+          Core.fieldTerm = (Typed.unTypedTerm pattern)},
+        Core.Field {
+          Core.fieldName = (Core.Name "guard"),
+          Core.fieldTerm = (Typed.unTypedTerm guard)}]}))
+
+-- | DSL accessor for the guard field of hydra.java.syntax.CasePattern
+casePatternGuard :: Typed.TypedTerm Syntax.CasePattern -> Typed.TypedTerm (Maybe Syntax.Guard)
+casePatternGuard x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CasePattern"),
+        Core.projectionFieldName = (Core.Name "guard")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the pattern field of hydra.java.syntax.CasePattern
+casePatternPattern :: Typed.TypedTerm Syntax.CasePattern -> Typed.TypedTerm Syntax.Pattern
+casePatternPattern x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CasePattern"),
+        Core.projectionFieldName = (Core.Name "pattern")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the guard field of hydra.java.syntax.CasePattern
+casePatternWithGuard :: Typed.TypedTerm Syntax.CasePattern -> Typed.TypedTerm (Maybe Syntax.Guard) -> Typed.TypedTerm Syntax.CasePattern
+casePatternWithGuard original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CasePattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pattern"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CasePattern"),
+              Core.projectionFieldName = (Core.Name "pattern")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "guard"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the pattern field of hydra.java.syntax.CasePattern
+casePatternWithPattern :: Typed.TypedTerm Syntax.CasePattern -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.CasePattern
+casePatternWithPattern original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CasePattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pattern"),
+          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.java.syntax.CasePattern"),
+              Core.projectionFieldName = (Core.Name "guard")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the lambda variant of hydra.java.syntax.CastExpression
+castExpressionLambda :: Typed.TypedTerm Syntax.CastExpression_Lambda -> Typed.TypedTerm Syntax.CastExpression
+castExpressionLambda x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.CastExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lambda"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the notPlusMinus variant of hydra.java.syntax.CastExpression
+castExpressionNotPlusMinus :: Typed.TypedTerm Syntax.CastExpression_NotPlusMinus -> Typed.TypedTerm Syntax.CastExpression
+castExpressionNotPlusMinus x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.CastExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "notPlusMinus"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primitive variant of hydra.java.syntax.CastExpression
+castExpressionPrimitive :: Typed.TypedTerm Syntax.CastExpression_Primitive -> Typed.TypedTerm Syntax.CastExpression
+castExpressionPrimitive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.CastExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primitive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.CastExpression_Lambda
+castExpression_Lambda :: Typed.TypedTerm Syntax.CastExpression_RefAndBounds -> Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.CastExpression_Lambda
+castExpression_Lambda refAndBounds expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_Lambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "refAndBounds"),
+          Core.fieldTerm = (Typed.unTypedTerm refAndBounds)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.CastExpression_Lambda
+castExpression_LambdaExpression :: Typed.TypedTerm Syntax.CastExpression_Lambda -> Typed.TypedTerm Syntax.LambdaExpression
+castExpression_LambdaExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_Lambda"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the refAndBounds field of hydra.java.syntax.CastExpression_Lambda
+castExpression_LambdaRefAndBounds :: Typed.TypedTerm Syntax.CastExpression_Lambda -> Typed.TypedTerm Syntax.CastExpression_RefAndBounds
+castExpression_LambdaRefAndBounds x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_Lambda"),
+        Core.projectionFieldName = (Core.Name "refAndBounds")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.CastExpression_Lambda
+castExpression_LambdaWithExpression :: Typed.TypedTerm Syntax.CastExpression_Lambda -> Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.CastExpression_Lambda
+castExpression_LambdaWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_Lambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "refAndBounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_Lambda"),
+              Core.projectionFieldName = (Core.Name "refAndBounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the refAndBounds field of hydra.java.syntax.CastExpression_Lambda
+castExpression_LambdaWithRefAndBounds :: Typed.TypedTerm Syntax.CastExpression_Lambda -> Typed.TypedTerm Syntax.CastExpression_RefAndBounds -> Typed.TypedTerm Syntax.CastExpression_Lambda
+castExpression_LambdaWithRefAndBounds original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_Lambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "refAndBounds"),
+          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.java.syntax.CastExpression_Lambda"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.CastExpression_NotPlusMinus
+castExpression_NotPlusMinus :: Typed.TypedTerm Syntax.CastExpression_RefAndBounds -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.CastExpression_NotPlusMinus
+castExpression_NotPlusMinus refAndBounds expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_NotPlusMinus"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "refAndBounds"),
+          Core.fieldTerm = (Typed.unTypedTerm refAndBounds)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.CastExpression_NotPlusMinus
+castExpression_NotPlusMinusExpression :: Typed.TypedTerm Syntax.CastExpression_NotPlusMinus -> Typed.TypedTerm Syntax.UnaryExpression
+castExpression_NotPlusMinusExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_NotPlusMinus"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the refAndBounds field of hydra.java.syntax.CastExpression_NotPlusMinus
+castExpression_NotPlusMinusRefAndBounds :: Typed.TypedTerm Syntax.CastExpression_NotPlusMinus -> Typed.TypedTerm Syntax.CastExpression_RefAndBounds
+castExpression_NotPlusMinusRefAndBounds x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_NotPlusMinus"),
+        Core.projectionFieldName = (Core.Name "refAndBounds")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.CastExpression_NotPlusMinus
+castExpression_NotPlusMinusWithExpression :: Typed.TypedTerm Syntax.CastExpression_NotPlusMinus -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.CastExpression_NotPlusMinus
+castExpression_NotPlusMinusWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_NotPlusMinus"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "refAndBounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_NotPlusMinus"),
+              Core.projectionFieldName = (Core.Name "refAndBounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the refAndBounds field of hydra.java.syntax.CastExpression_NotPlusMinus
+castExpression_NotPlusMinusWithRefAndBounds :: Typed.TypedTerm Syntax.CastExpression_NotPlusMinus -> Typed.TypedTerm Syntax.CastExpression_RefAndBounds -> Typed.TypedTerm Syntax.CastExpression_NotPlusMinus
+castExpression_NotPlusMinusWithRefAndBounds original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_NotPlusMinus"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "refAndBounds"),
+          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.java.syntax.CastExpression_NotPlusMinus"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.CastExpression_Primitive
+castExpression_Primitive :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.CastExpression_Primitive
+castExpression_Primitive type_ expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_Primitive"),
+      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.java.syntax.CastExpression_Primitive
+castExpression_PrimitiveExpression :: Typed.TypedTerm Syntax.CastExpression_Primitive -> Typed.TypedTerm Syntax.UnaryExpression
+castExpression_PrimitiveExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_Primitive"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.CastExpression_Primitive
+castExpression_PrimitiveType :: Typed.TypedTerm Syntax.CastExpression_Primitive -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations
+castExpression_PrimitiveType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_Primitive"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.CastExpression_Primitive
+castExpression_PrimitiveWithExpression :: Typed.TypedTerm Syntax.CastExpression_Primitive -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.CastExpression_Primitive
+castExpression_PrimitiveWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_Primitive"),
+      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.java.syntax.CastExpression_Primitive"),
+              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.java.syntax.CastExpression_Primitive
+castExpression_PrimitiveWithType :: Typed.TypedTerm Syntax.CastExpression_Primitive -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm Syntax.CastExpression_Primitive
+castExpression_PrimitiveWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_Primitive"),
+      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.java.syntax.CastExpression_Primitive"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.CastExpression_RefAndBounds
+castExpression_RefAndBounds :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm [Syntax.AdditionalBound] -> Typed.TypedTerm Syntax.CastExpression_RefAndBounds
+castExpression_RefAndBounds type_ bounds =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_RefAndBounds"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Typed.unTypedTerm bounds)}]}))
+
+-- | DSL accessor for the bounds field of hydra.java.syntax.CastExpression_RefAndBounds
+castExpression_RefAndBoundsBounds :: Typed.TypedTerm Syntax.CastExpression_RefAndBounds -> Typed.TypedTerm [Syntax.AdditionalBound]
+castExpression_RefAndBoundsBounds x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_RefAndBounds"),
+        Core.projectionFieldName = (Core.Name "bounds")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.CastExpression_RefAndBounds
+castExpression_RefAndBoundsType :: Typed.TypedTerm Syntax.CastExpression_RefAndBounds -> Typed.TypedTerm Syntax.ReferenceType
+castExpression_RefAndBoundsType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_RefAndBounds"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the bounds field of hydra.java.syntax.CastExpression_RefAndBounds
+castExpression_RefAndBoundsWithBounds :: Typed.TypedTerm Syntax.CastExpression_RefAndBounds -> Typed.TypedTerm [Syntax.AdditionalBound] -> Typed.TypedTerm Syntax.CastExpression_RefAndBounds
+castExpression_RefAndBoundsWithBounds original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_RefAndBounds"),
+      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.java.syntax.CastExpression_RefAndBounds"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.CastExpression_RefAndBounds
+castExpression_RefAndBoundsWithType :: Typed.TypedTerm Syntax.CastExpression_RefAndBounds -> Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.CastExpression_RefAndBounds
+castExpression_RefAndBoundsWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CastExpression_RefAndBounds"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CastExpression_RefAndBounds"),
+              Core.projectionFieldName = (Core.Name "bounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.CatchClause
+catchClause :: Typed.TypedTerm (Maybe Syntax.CatchFormalParameter) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CatchClause
+catchClause parameter block =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameter"),
+          Core.fieldTerm = (Typed.unTypedTerm parameter)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm block)}]}))
+
+-- | DSL accessor for the block field of hydra.java.syntax.CatchClause
+catchClauseBlock :: Typed.TypedTerm Syntax.CatchClause -> Typed.TypedTerm Syntax.Block
+catchClauseBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchClause"),
+        Core.projectionFieldName = (Core.Name "block")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parameter field of hydra.java.syntax.CatchClause
+catchClauseParameter :: Typed.TypedTerm Syntax.CatchClause -> Typed.TypedTerm (Maybe Syntax.CatchFormalParameter)
+catchClauseParameter x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchClause"),
+        Core.projectionFieldName = (Core.Name "parameter")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the block field of hydra.java.syntax.CatchClause
+catchClauseWithBlock :: Typed.TypedTerm Syntax.CatchClause -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CatchClause
+catchClauseWithBlock original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameter"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchClause"),
+              Core.projectionFieldName = (Core.Name "parameter")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the parameter field of hydra.java.syntax.CatchClause
+catchClauseWithParameter :: Typed.TypedTerm Syntax.CatchClause -> Typed.TypedTerm (Maybe Syntax.CatchFormalParameter) -> Typed.TypedTerm Syntax.CatchClause
+catchClauseWithParameter original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchClause"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameter"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchClause"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.CatchFormalParameter
+catchFormalParameter :: Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.CatchType -> Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.CatchFormalParameter
+catchFormalParameter modifiers type_ id =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Typed.unTypedTerm id)}]}))
+
+-- | DSL accessor for the id field of hydra.java.syntax.CatchFormalParameter
+catchFormalParameterId :: Typed.TypedTerm Syntax.CatchFormalParameter -> Typed.TypedTerm Syntax.VariableDeclaratorId
+catchFormalParameterId x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+        Core.projectionFieldName = (Core.Name "id")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.CatchFormalParameter
+catchFormalParameterModifiers :: Typed.TypedTerm Syntax.CatchFormalParameter -> Typed.TypedTerm [Syntax.VariableModifier]
+catchFormalParameterModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.CatchFormalParameter
+catchFormalParameterType :: Typed.TypedTerm Syntax.CatchFormalParameter -> Typed.TypedTerm Syntax.CatchType
+catchFormalParameterType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the id field of hydra.java.syntax.CatchFormalParameter
+catchFormalParameterWithId :: Typed.TypedTerm Syntax.CatchFormalParameter -> Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.CatchFormalParameter
+catchFormalParameterWithId original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.CatchFormalParameter"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.CatchFormalParameter
+catchFormalParameterWithModifiers :: Typed.TypedTerm Syntax.CatchFormalParameter -> Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.CatchFormalParameter
+catchFormalParameterWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.CatchFormalParameter"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+              Core.projectionFieldName = (Core.Name "id")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.CatchFormalParameter
+catchFormalParameterWithType :: Typed.TypedTerm Syntax.CatchFormalParameter -> Typed.TypedTerm Syntax.CatchType -> Typed.TypedTerm Syntax.CatchFormalParameter
+catchFormalParameterWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchFormalParameter"),
+              Core.projectionFieldName = (Core.Name "id")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.CatchType
+catchType :: Typed.TypedTerm Syntax.UnannClassType -> Typed.TypedTerm [Syntax.ClassType] -> Typed.TypedTerm Syntax.CatchType
+catchType type_ types =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "types"),
+          Core.fieldTerm = (Typed.unTypedTerm types)}]}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.CatchType
+catchTypeType :: Typed.TypedTerm Syntax.CatchType -> Typed.TypedTerm Syntax.UnannClassType
+catchTypeType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchType"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the types field of hydra.java.syntax.CatchType
+catchTypeTypes :: Typed.TypedTerm Syntax.CatchType -> Typed.TypedTerm [Syntax.ClassType]
+catchTypeTypes x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchType"),
+        Core.projectionFieldName = (Core.Name "types")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the type field of hydra.java.syntax.CatchType
+catchTypeWithType :: Typed.TypedTerm Syntax.CatchType -> Typed.TypedTerm Syntax.UnannClassType -> Typed.TypedTerm Syntax.CatchType
+catchTypeWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "types"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CatchType"),
+              Core.projectionFieldName = (Core.Name "types")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the types field of hydra.java.syntax.CatchType
+catchTypeWithTypes :: Typed.TypedTerm Syntax.CatchType -> Typed.TypedTerm [Syntax.ClassType] -> Typed.TypedTerm Syntax.CatchType
+catchTypeWithTypes original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CatchType"),
+      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.java.syntax.CatchType"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "types"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.java.syntax.Catches wrapper
+catches :: Typed.TypedTerm [Syntax.CatchClause] -> Typed.TypedTerm Syntax.Catches
+catches x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.Catches"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.ClassBody wrapper
+classBody :: Typed.TypedTerm [Syntax.ClassBodyDeclarationWithComments] -> Typed.TypedTerm Syntax.ClassBody
+classBody x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ClassBody"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the classMember variant of hydra.java.syntax.ClassBodyDeclaration
+classBodyDeclarationClassMember :: Typed.TypedTerm Syntax.ClassMemberDeclaration -> Typed.TypedTerm Syntax.ClassBodyDeclaration
+classBodyDeclarationClassMember x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classMember"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the constructorDeclaration variant of hydra.java.syntax.ClassBodyDeclaration
+classBodyDeclarationConstructorDeclaration :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ClassBodyDeclaration
+classBodyDeclarationConstructorDeclaration x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "constructorDeclaration"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the instanceInitializer variant of hydra.java.syntax.ClassBodyDeclaration
+classBodyDeclarationInstanceInitializer :: Typed.TypedTerm Syntax.InstanceInitializer -> Typed.TypedTerm Syntax.ClassBodyDeclaration
+classBodyDeclarationInstanceInitializer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "instanceInitializer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the staticInitializer variant of hydra.java.syntax.ClassBodyDeclaration
+classBodyDeclarationStaticInitializer :: Typed.TypedTerm Syntax.StaticInitializer -> Typed.TypedTerm Syntax.ClassBodyDeclaration
+classBodyDeclarationStaticInitializer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "staticInitializer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ClassBodyDeclarationWithComments
+classBodyDeclarationWithComments :: Typed.TypedTerm Syntax.ClassBodyDeclaration -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.ClassBodyDeclarationWithComments
+classBodyDeclarationWithComments value comments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Typed.unTypedTerm comments)}]}))
+
+-- | DSL accessor for the comments field of hydra.java.syntax.ClassBodyDeclarationWithComments
+classBodyDeclarationWithCommentsComments :: Typed.TypedTerm Syntax.ClassBodyDeclarationWithComments -> Typed.TypedTerm (Maybe String)
+classBodyDeclarationWithCommentsComments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"),
+        Core.projectionFieldName = (Core.Name "comments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.java.syntax.ClassBodyDeclarationWithComments
+classBodyDeclarationWithCommentsValue :: Typed.TypedTerm Syntax.ClassBodyDeclarationWithComments -> Typed.TypedTerm Syntax.ClassBodyDeclaration
+classBodyDeclarationWithCommentsValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the comments field of hydra.java.syntax.ClassBodyDeclarationWithComments
+classBodyDeclarationWithCommentsWithComments :: Typed.TypedTerm Syntax.ClassBodyDeclarationWithComments -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.ClassBodyDeclarationWithComments
+classBodyDeclarationWithCommentsWithComments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the value field of hydra.java.syntax.ClassBodyDeclarationWithComments
+classBodyDeclarationWithCommentsWithValue :: Typed.TypedTerm Syntax.ClassBodyDeclarationWithComments -> Typed.TypedTerm Syntax.ClassBodyDeclaration -> Typed.TypedTerm Syntax.ClassBodyDeclarationWithComments
+classBodyDeclarationWithCommentsWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"),
+              Core.projectionFieldName = (Core.Name "comments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the enum variant of hydra.java.syntax.ClassDeclaration
+classDeclarationEnum :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.ClassDeclaration
+classDeclarationEnum x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "enum"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the normal variant of hydra.java.syntax.ClassDeclaration
+classDeclarationNormal :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm Syntax.ClassDeclaration
+classDeclarationNormal x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "normal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the record variant of hydra.java.syntax.ClassDeclaration
+classDeclarationRecord :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm Syntax.ClassDeclaration
+classDeclarationRecord x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "record"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ClassInstanceCreationExpression
+classInstanceCreationExpression :: Typed.TypedTerm (Maybe Syntax.ClassInstanceCreationExpression_Qualifier) -> Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm Syntax.ClassInstanceCreationExpression
+classInstanceCreationExpression qualifier expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassInstanceCreationExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.ClassInstanceCreationExpression
+classInstanceCreationExpressionExpression :: Typed.TypedTerm Syntax.ClassInstanceCreationExpression -> Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression
+classInstanceCreationExpressionExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassInstanceCreationExpression"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the qualifier field of hydra.java.syntax.ClassInstanceCreationExpression
+classInstanceCreationExpressionQualifier :: Typed.TypedTerm Syntax.ClassInstanceCreationExpression -> Typed.TypedTerm (Maybe Syntax.ClassInstanceCreationExpression_Qualifier)
+classInstanceCreationExpressionQualifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassInstanceCreationExpression"),
+        Core.projectionFieldName = (Core.Name "qualifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.ClassInstanceCreationExpression
+classInstanceCreationExpressionWithExpression :: Typed.TypedTerm Syntax.ClassInstanceCreationExpression -> Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm Syntax.ClassInstanceCreationExpression
+classInstanceCreationExpressionWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassInstanceCreationExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "qualifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the qualifier field of hydra.java.syntax.ClassInstanceCreationExpression
+classInstanceCreationExpressionWithQualifier :: Typed.TypedTerm Syntax.ClassInstanceCreationExpression -> Typed.TypedTerm (Maybe Syntax.ClassInstanceCreationExpression_Qualifier) -> Typed.TypedTerm Syntax.ClassInstanceCreationExpression
+classInstanceCreationExpressionWithQualifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassInstanceCreationExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          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.java.syntax.ClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the expression variant of hydra.java.syntax.ClassInstanceCreationExpression_Qualifier
+classInstanceCreationExpression_QualifierExpression :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.ClassInstanceCreationExpression_Qualifier
+classInstanceCreationExpression_QualifierExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassInstanceCreationExpression_Qualifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primary variant of hydra.java.syntax.ClassInstanceCreationExpression_Qualifier
+classInstanceCreationExpression_QualifierPrimary :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.ClassInstanceCreationExpression_Qualifier
+classInstanceCreationExpression_QualifierPrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassInstanceCreationExpression_Qualifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the boolean variant of hydra.java.syntax.ClassLiteral
+classLiteralBoolean :: Typed.TypedTerm Syntax.BooleanArray -> Typed.TypedTerm Syntax.ClassLiteral
+classLiteralBoolean x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassLiteral"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "boolean"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the numericType variant of hydra.java.syntax.ClassLiteral
+classLiteralNumericType :: Typed.TypedTerm Syntax.NumericTypeArray -> Typed.TypedTerm Syntax.ClassLiteral
+classLiteralNumericType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassLiteral"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "numericType"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.java.syntax.ClassLiteral
+classLiteralType :: Typed.TypedTerm Syntax.TypeNameArray -> Typed.TypedTerm Syntax.ClassLiteral
+classLiteralType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassLiteral"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the void variant of hydra.java.syntax.ClassLiteral
+classLiteralVoid :: Typed.TypedTerm Syntax.ClassLiteral
+classLiteralVoid =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassLiteral"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "void"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the class variant of hydra.java.syntax.ClassMemberDeclaration
+classMemberDeclarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
+classMemberDeclarationClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the field variant of hydra.java.syntax.ClassMemberDeclaration
+classMemberDeclarationField :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
+classMemberDeclarationField x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "field"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interface variant of hydra.java.syntax.ClassMemberDeclaration
+classMemberDeclarationInterface :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
+classMemberDeclarationInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the method variant of hydra.java.syntax.ClassMemberDeclaration
+classMemberDeclarationMethod :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
+classMemberDeclarationMethod x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "method"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the none variant of hydra.java.syntax.ClassMemberDeclaration
+classMemberDeclarationNone :: Typed.TypedTerm Syntax.ClassMemberDeclaration
+classMemberDeclarationNone =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "none"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the abstract variant of hydra.java.syntax.ClassModifier
+classModifierAbstract :: Typed.TypedTerm Syntax.ClassModifier
+classModifierAbstract =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "abstract"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.ClassModifier
+classModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.ClassModifier
+classModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the final variant of hydra.java.syntax.ClassModifier
+classModifierFinal :: Typed.TypedTerm Syntax.ClassModifier
+classModifierFinal =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "final"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the nonSealed variant of hydra.java.syntax.ClassModifier
+classModifierNonSealed :: Typed.TypedTerm Syntax.ClassModifier
+classModifierNonSealed =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "nonSealed"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the private variant of hydra.java.syntax.ClassModifier
+classModifierPrivate :: Typed.TypedTerm Syntax.ClassModifier
+classModifierPrivate =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "private"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the protected variant of hydra.java.syntax.ClassModifier
+classModifierProtected :: Typed.TypedTerm Syntax.ClassModifier
+classModifierProtected =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "protected"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the public variant of hydra.java.syntax.ClassModifier
+classModifierPublic :: Typed.TypedTerm Syntax.ClassModifier
+classModifierPublic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "public"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the sealed variant of hydra.java.syntax.ClassModifier
+classModifierSealed :: Typed.TypedTerm Syntax.ClassModifier
+classModifierSealed =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "sealed"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the static variant of hydra.java.syntax.ClassModifier
+classModifierStatic :: Typed.TypedTerm Syntax.ClassModifier
+classModifierStatic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "static"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the strictfp variant of hydra.java.syntax.ClassModifier
+classModifierStrictfp :: Typed.TypedTerm Syntax.ClassModifier
+classModifierStrictfp =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "strictfp"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the class variant of hydra.java.syntax.ClassOrInterfaceType
+classOrInterfaceTypeClass :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.ClassOrInterfaceType
+classOrInterfaceTypeClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interface variant of hydra.java.syntax.ClassOrInterfaceType
+classOrInterfaceTypeInterface :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.ClassOrInterfaceType
+classOrInterfaceTypeInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ClassOrInterfaceTypeToInstantiate
+classOrInterfaceTypeToInstantiate :: Typed.TypedTerm [Syntax.AnnotatedIdentifier] -> Typed.TypedTerm (Maybe Syntax.TypeArgumentsOrDiamond) -> Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate
+classOrInterfaceTypeToInstantiate identifiers typeArguments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm identifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))
+
+-- | DSL accessor for the identifiers field of hydra.java.syntax.ClassOrInterfaceTypeToInstantiate
+classOrInterfaceTypeToInstantiateIdentifiers :: Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate -> Typed.TypedTerm [Syntax.AnnotatedIdentifier]
+classOrInterfaceTypeToInstantiateIdentifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"),
+        Core.projectionFieldName = (Core.Name "identifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.ClassOrInterfaceTypeToInstantiate
+classOrInterfaceTypeToInstantiateTypeArguments :: Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate -> Typed.TypedTerm (Maybe Syntax.TypeArgumentsOrDiamond)
+classOrInterfaceTypeToInstantiateTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifiers field of hydra.java.syntax.ClassOrInterfaceTypeToInstantiate
+classOrInterfaceTypeToInstantiateWithIdentifiers :: Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate -> Typed.TypedTerm [Syntax.AnnotatedIdentifier] -> Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate
+classOrInterfaceTypeToInstantiateWithIdentifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.ClassOrInterfaceTypeToInstantiate
+classOrInterfaceTypeToInstantiateWithTypeArguments :: Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate -> Typed.TypedTerm (Maybe Syntax.TypeArgumentsOrDiamond) -> Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate
+classOrInterfaceTypeToInstantiateWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"),
+              Core.projectionFieldName = (Core.Name "identifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.ClassType
+classType :: Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.ClassTypeQualifier -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.ClassType
+classType annotations qualifier identifier arguments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm arguments)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.ClassType
+classTypeAnnotations :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm [Syntax.Annotation]
+classTypeAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the arguments field of hydra.java.syntax.ClassType
+classTypeArguments :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm [Syntax.TypeArgument]
+classTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+        Core.projectionFieldName = (Core.Name "arguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.ClassType
+classTypeIdentifier :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.TypeIdentifier
+classTypeIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the qualifier field of hydra.java.syntax.ClassType
+classTypeQualifier :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.ClassTypeQualifier
+classTypeQualifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+        Core.projectionFieldName = (Core.Name "qualifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the none variant of hydra.java.syntax.ClassTypeQualifier
+classTypeQualifierNone :: Typed.TypedTerm Syntax.ClassTypeQualifier
+classTypeQualifierNone =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassTypeQualifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "none"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the package variant of hydra.java.syntax.ClassTypeQualifier
+classTypeQualifierPackage :: Typed.TypedTerm Syntax.PackageName -> Typed.TypedTerm Syntax.ClassTypeQualifier
+classTypeQualifierPackage x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassTypeQualifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "package"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the parent variant of hydra.java.syntax.ClassTypeQualifier
+classTypeQualifierParent :: Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm Syntax.ClassTypeQualifier
+classTypeQualifierParent x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ClassTypeQualifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "parent"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.ClassType
+classTypeWithAnnotations :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.ClassType
+classTypeWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "qualifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the arguments field of hydra.java.syntax.ClassType
+classTypeWithArguments :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.ClassType
+classTypeWithArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "qualifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.ClassType
+classTypeWithIdentifier :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.ClassType
+classTypeWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "qualifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          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.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the qualifier field of hydra.java.syntax.ClassType
+classTypeWithQualifier :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.ClassTypeQualifier -> Typed.TypedTerm Syntax.ClassType
+classTypeWithQualifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ClassType"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.CompactConstructorDeclaration
+compactConstructorDeclaration :: Typed.TypedTerm [Syntax.ConstructorModifier] -> Typed.TypedTerm Syntax.SimpleTypeName -> Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm Syntax.CompactConstructorDeclaration
+compactConstructorDeclaration modifiers name body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.CompactConstructorDeclaration
+compactConstructorDeclarationBody :: Typed.TypedTerm Syntax.CompactConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorBody
+compactConstructorDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.CompactConstructorDeclaration
+compactConstructorDeclarationModifiers :: Typed.TypedTerm Syntax.CompactConstructorDeclaration -> Typed.TypedTerm [Syntax.ConstructorModifier]
+compactConstructorDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.java.syntax.CompactConstructorDeclaration
+compactConstructorDeclarationName :: Typed.TypedTerm Syntax.CompactConstructorDeclaration -> Typed.TypedTerm Syntax.SimpleTypeName
+compactConstructorDeclarationName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.CompactConstructorDeclaration
+compactConstructorDeclarationWithBody :: Typed.TypedTerm Syntax.CompactConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm Syntax.CompactConstructorDeclaration
+compactConstructorDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.CompactConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.CompactConstructorDeclaration
+compactConstructorDeclarationWithModifiers :: Typed.TypedTerm Syntax.CompactConstructorDeclaration -> Typed.TypedTerm [Syntax.ConstructorModifier] -> Typed.TypedTerm Syntax.CompactConstructorDeclaration
+compactConstructorDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.CompactConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            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.java.syntax.CompactConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.java.syntax.CompactConstructorDeclaration
+compactConstructorDeclarationWithName :: Typed.TypedTerm Syntax.CompactConstructorDeclaration -> Typed.TypedTerm Syntax.SimpleTypeName -> Typed.TypedTerm Syntax.CompactConstructorDeclaration
+compactConstructorDeclarationWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.CompactConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          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.java.syntax.CompactConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the modular variant of hydra.java.syntax.CompilationUnit
+compilationUnitModular :: Typed.TypedTerm Syntax.ModularCompilationUnit -> Typed.TypedTerm Syntax.CompilationUnit
+compilationUnitModular x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.CompilationUnit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "modular"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ordinary variant of hydra.java.syntax.CompilationUnit
+compilationUnitOrdinary :: Typed.TypedTerm Syntax.OrdinaryCompilationUnit -> Typed.TypedTerm Syntax.CompilationUnit
+compilationUnitOrdinary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.CompilationUnit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ordinary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.ConditionalAndExpression wrapper
+conditionalAndExpression :: Typed.TypedTerm [Syntax.InclusiveOrExpression] -> Typed.TypedTerm Syntax.ConditionalAndExpression
+conditionalAndExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ConditionalAndExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.ConditionalExpression
+conditionalExpressionSimple :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalExpression
+conditionalExpressionSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ternaryCond variant of hydra.java.syntax.ConditionalExpression
+conditionalExpressionTernaryCond :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond -> Typed.TypedTerm Syntax.ConditionalExpression
+conditionalExpressionTernaryCond x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ternaryCond"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ternaryLambda variant of hydra.java.syntax.ConditionalExpression
+conditionalExpressionTernaryLambda :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda -> Typed.TypedTerm Syntax.ConditionalExpression
+conditionalExpressionTernaryLambda x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ternaryLambda"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCond :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCond cond ifTrue ifFalse =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifTrue"),
+          Core.fieldTerm = (Typed.unTypedTerm ifTrue)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifFalse"),
+          Core.fieldTerm = (Typed.unTypedTerm ifFalse)}]}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondCond :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond -> Typed.TypedTerm Syntax.ConditionalOrExpression
+conditionalExpression_TernaryCondCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the ifFalse field of hydra.java.syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondIfFalse :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond -> Typed.TypedTerm Syntax.ConditionalExpression
+conditionalExpression_TernaryCondIfFalse x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+        Core.projectionFieldName = (Core.Name "ifFalse")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the ifTrue field of hydra.java.syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondIfTrue :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond -> Typed.TypedTerm Syntax.Expression
+conditionalExpression_TernaryCondIfTrue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+        Core.projectionFieldName = (Core.Name "ifTrue")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondWithCond :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond -> Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifTrue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+              Core.projectionFieldName = (Core.Name "ifTrue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifFalse"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+              Core.projectionFieldName = (Core.Name "ifFalse")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the ifFalse field of hydra.java.syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondWithIfFalse :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond -> Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondWithIfFalse original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifTrue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+              Core.projectionFieldName = (Core.Name "ifTrue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifFalse"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the ifTrue field of hydra.java.syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondWithIfTrue :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConditionalExpression_TernaryCond
+conditionalExpression_TernaryCondWithIfTrue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifTrue"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifFalse"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"),
+              Core.projectionFieldName = (Core.Name "ifFalse")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambda :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambda cond ifTrue ifFalse =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifTrue"),
+          Core.fieldTerm = (Typed.unTypedTerm ifTrue)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifFalse"),
+          Core.fieldTerm = (Typed.unTypedTerm ifFalse)}]}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaCond :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda -> Typed.TypedTerm Syntax.ConditionalOrExpression
+conditionalExpression_TernaryLambdaCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the ifFalse field of hydra.java.syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaIfFalse :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda -> Typed.TypedTerm Syntax.LambdaExpression
+conditionalExpression_TernaryLambdaIfFalse x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+        Core.projectionFieldName = (Core.Name "ifFalse")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the ifTrue field of hydra.java.syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaIfTrue :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda -> Typed.TypedTerm Syntax.Expression
+conditionalExpression_TernaryLambdaIfTrue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+        Core.projectionFieldName = (Core.Name "ifTrue")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaWithCond :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda -> Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifTrue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+              Core.projectionFieldName = (Core.Name "ifTrue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifFalse"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+              Core.projectionFieldName = (Core.Name "ifFalse")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the ifFalse field of hydra.java.syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaWithIfFalse :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda -> Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaWithIfFalse original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifTrue"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+              Core.projectionFieldName = (Core.Name "ifTrue")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifFalse"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the ifTrue field of hydra.java.syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaWithIfTrue :: Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConditionalExpression_TernaryLambda
+conditionalExpression_TernaryLambdaWithIfTrue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifTrue"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ifFalse"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"),
+              Core.projectionFieldName = (Core.Name "ifFalse")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.ConditionalOrExpression wrapper
+conditionalOrExpression :: Typed.TypedTerm [Syntax.ConditionalAndExpression] -> Typed.TypedTerm Syntax.ConditionalOrExpression
+conditionalOrExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ConditionalOrExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.ConstantDeclaration
+constantDeclaration :: Typed.TypedTerm [Syntax.ConstantModifier] -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.ConstantDeclaration
+constantDeclaration modifiers type_ variables =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variables"),
+          Core.fieldTerm = (Typed.unTypedTerm variables)}]}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.ConstantDeclaration
+constantDeclarationModifiers :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantModifier]
+constantDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.ConstantDeclaration
+constantDeclarationType :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.UnannType
+constantDeclarationType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the variables field of hydra.java.syntax.ConstantDeclaration
+constantDeclarationVariables :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator]
+constantDeclarationVariables x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+        Core.projectionFieldName = (Core.Name "variables")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.ConstantDeclaration
+constantDeclarationWithModifiers :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantModifier] -> Typed.TypedTerm Syntax.ConstantDeclaration
+constantDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.ConstantDeclaration"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variables"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+              Core.projectionFieldName = (Core.Name "variables")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.ConstantDeclaration
+constantDeclarationWithType :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.ConstantDeclaration
+constantDeclarationWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variables"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+              Core.projectionFieldName = (Core.Name "variables")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the variables field of hydra.java.syntax.ConstantDeclaration
+constantDeclarationWithVariables :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.ConstantDeclaration
+constantDeclarationWithVariables original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstantDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.ConstantDeclaration"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variables"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.java.syntax.ConstantExpression wrapper
+constantExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConstantExpression
+constantExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ConstantExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.ConstantModifier
+constantModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.ConstantModifier
+constantModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConstantModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the final variant of hydra.java.syntax.ConstantModifier
+constantModifierFinal :: Typed.TypedTerm Syntax.ConstantModifier
+constantModifierFinal =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConstantModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "final"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the public variant of hydra.java.syntax.ConstantModifier
+constantModifierPublic :: Typed.TypedTerm Syntax.ConstantModifier
+constantModifierPublic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConstantModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "public"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the static variant of hydra.java.syntax.ConstantModifier
+constantModifierStatic :: Typed.TypedTerm Syntax.ConstantModifier
+constantModifierStatic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConstantModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "static"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.java.syntax.ConstructorBody
+constructorBody :: Typed.TypedTerm (Maybe Syntax.ExplicitConstructorInvocation) -> Typed.TypedTerm [Syntax.BlockStatement] -> Typed.TypedTerm Syntax.ConstructorBody
+constructorBody invocation statements =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorBody"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "invocation"),
+          Core.fieldTerm = (Typed.unTypedTerm invocation)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm statements)}]}))
+
+-- | DSL accessor for the invocation field of hydra.java.syntax.ConstructorBody
+constructorBodyInvocation :: Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm (Maybe Syntax.ExplicitConstructorInvocation)
+constructorBodyInvocation x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorBody"),
+        Core.projectionFieldName = (Core.Name "invocation")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the statements field of hydra.java.syntax.ConstructorBody
+constructorBodyStatements :: Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm [Syntax.BlockStatement]
+constructorBodyStatements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorBody"),
+        Core.projectionFieldName = (Core.Name "statements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the invocation field of hydra.java.syntax.ConstructorBody
+constructorBodyWithInvocation :: Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm (Maybe Syntax.ExplicitConstructorInvocation) -> Typed.TypedTerm Syntax.ConstructorBody
+constructorBodyWithInvocation original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorBody"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "invocation"),
+          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.java.syntax.ConstructorBody"),
+              Core.projectionFieldName = (Core.Name "statements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statements field of hydra.java.syntax.ConstructorBody
+constructorBodyWithStatements :: Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm [Syntax.BlockStatement] -> Typed.TypedTerm Syntax.ConstructorBody
+constructorBodyWithStatements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorBody"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "invocation"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorBody"),
+              Core.projectionFieldName = (Core.Name "invocation")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.ConstructorDeclaration
+constructorDeclaration :: Typed.TypedTerm [Syntax.ConstructorModifier] -> Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.Throws) -> Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm Syntax.ConstructorDeclaration
+constructorDeclaration modifiers constructor throws body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "constructor"),
+          Core.fieldTerm = (Typed.unTypedTerm constructor)},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Typed.unTypedTerm throws)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.ConstructorDeclaration
+constructorDeclarationBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorBody
+constructorDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the constructor field of hydra.java.syntax.ConstructorDeclaration
+constructorDeclarationConstructor :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorDeclarator
+constructorDeclarationConstructor x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+        Core.projectionFieldName = (Core.Name "constructor")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.ConstructorDeclaration
+constructorDeclarationModifiers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.ConstructorModifier]
+constructorDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the throws field of hydra.java.syntax.ConstructorDeclaration
+constructorDeclarationThrows :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Throws)
+constructorDeclarationThrows x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+        Core.projectionFieldName = (Core.Name "throws")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.ConstructorDeclaration
+constructorDeclarationWithBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm Syntax.ConstructorDeclaration
+constructorDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constructor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "constructor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "throws")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the constructor field of hydra.java.syntax.ConstructorDeclaration
+constructorDeclarationWithConstructor :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.ConstructorDeclaration
+constructorDeclarationWithConstructor original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constructor"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "throws")})),
+            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.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.ConstructorDeclaration
+constructorDeclarationWithModifiers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.ConstructorModifier] -> Typed.TypedTerm Syntax.ConstructorDeclaration
+constructorDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "constructor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "constructor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "throws")})),
+            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.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the throws field of hydra.java.syntax.ConstructorDeclaration
+constructorDeclarationWithThrows :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Throws) -> Typed.TypedTerm Syntax.ConstructorDeclaration
+constructorDeclarationWithThrows original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "constructor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "constructor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          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.java.syntax.ConstructorDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.ConstructorDeclarator
+constructorDeclarator :: Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.SimpleTypeName -> Typed.TypedTerm (Maybe Syntax.ReceiverParameter) -> Typed.TypedTerm [Syntax.FormalParameter] -> Typed.TypedTerm Syntax.ConstructorDeclarator
+constructorDeclarator parameters name receiverParameter formalParameters =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm parameters)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Typed.unTypedTerm receiverParameter)},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Typed.unTypedTerm formalParameters)}]}))
+
+-- | DSL accessor for the formalParameters field of hydra.java.syntax.ConstructorDeclarator
+constructorDeclaratorFormalParameters :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm [Syntax.FormalParameter]
+constructorDeclaratorFormalParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+        Core.projectionFieldName = (Core.Name "formalParameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.java.syntax.ConstructorDeclarator
+constructorDeclaratorName :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.SimpleTypeName
+constructorDeclaratorName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parameters field of hydra.java.syntax.ConstructorDeclarator
+constructorDeclaratorParameters :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm [Syntax.TypeParameter]
+constructorDeclaratorParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+        Core.projectionFieldName = (Core.Name "parameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the receiverParameter field of hydra.java.syntax.ConstructorDeclarator
+constructorDeclaratorReceiverParameter :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.ReceiverParameter)
+constructorDeclaratorReceiverParameter x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+        Core.projectionFieldName = (Core.Name "receiverParameter")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the formalParameters field of hydra.java.syntax.ConstructorDeclarator
+constructorDeclaratorWithFormalParameters :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm [Syntax.FormalParameter] -> Typed.TypedTerm Syntax.ConstructorDeclarator
+constructorDeclaratorWithFormalParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+      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.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            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.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "receiverParameter")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.java.syntax.ConstructorDeclarator
+constructorDeclaratorWithName :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.SimpleTypeName -> Typed.TypedTerm Syntax.ConstructorDeclarator
+constructorDeclaratorWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+      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.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "receiverParameter")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "formalParameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the parameters field of hydra.java.syntax.ConstructorDeclarator
+constructorDeclaratorWithParameters :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.ConstructorDeclarator
+constructorDeclaratorWithParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          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.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "receiverParameter")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "formalParameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the receiverParameter field of hydra.java.syntax.ConstructorDeclarator
+constructorDeclaratorWithReceiverParameter :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.ReceiverParameter) -> Typed.TypedTerm Syntax.ConstructorDeclarator
+constructorDeclaratorWithReceiverParameter original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+      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.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            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.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ConstructorDeclarator"),
+              Core.projectionFieldName = (Core.Name "formalParameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.ConstructorModifier
+constructorModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.ConstructorModifier
+constructorModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConstructorModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the private variant of hydra.java.syntax.ConstructorModifier
+constructorModifierPrivate :: Typed.TypedTerm Syntax.ConstructorModifier
+constructorModifierPrivate =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConstructorModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "private"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the protected variant of hydra.java.syntax.ConstructorModifier
+constructorModifierProtected :: Typed.TypedTerm Syntax.ConstructorModifier
+constructorModifierProtected =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConstructorModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "protected"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the public variant of hydra.java.syntax.ConstructorModifier
+constructorModifierPublic :: Typed.TypedTerm Syntax.ConstructorModifier
+constructorModifierPublic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ConstructorModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "public"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.java.syntax.ContinueStatement wrapper
+continueStatement :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ContinueStatement
+continueStatement x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ContinueStatement"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.DefaultValue wrapper
+defaultValue :: Typed.TypedTerm Syntax.ElementValue -> Typed.TypedTerm Syntax.DefaultValue
+defaultValue x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.DefaultValue"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.DimExpr
+dimExpr :: Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.DimExpr
+dimExpr annotations expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.DimExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.DimExpr
+dimExprAnnotations :: Typed.TypedTerm Syntax.DimExpr -> Typed.TypedTerm [Syntax.Annotation]
+dimExprAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.DimExpr"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.DimExpr
+dimExprExpression :: Typed.TypedTerm Syntax.DimExpr -> Typed.TypedTerm (Maybe Syntax.Expression)
+dimExprExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.DimExpr"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.DimExpr
+dimExprWithAnnotations :: Typed.TypedTerm Syntax.DimExpr -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.DimExpr
+dimExprWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.DimExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          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.java.syntax.DimExpr"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.DimExpr
+dimExprWithExpression :: Typed.TypedTerm Syntax.DimExpr -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.DimExpr
+dimExprWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.DimExpr"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.DimExpr"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.java.syntax.Dims wrapper
+dims :: Typed.TypedTerm [[Syntax.Annotation]] -> Typed.TypedTerm Syntax.Dims
+dims x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.Dims"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.DoStatement
+doStatement :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DoStatement
+doStatement body cond =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.DoStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.DoStatement
+doStatementBody :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.Statement
+doStatementBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.DoStatement"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.DoStatement
+doStatementCond :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.Expression
+doStatementCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.DoStatement"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.DoStatement
+doStatementWithBody :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.DoStatement
+doStatementWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.DoStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.DoStatement"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.DoStatement
+doStatementWithCond :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DoStatement
+doStatementWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.DoStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.DoStatement"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.ElementValue
+elementValueAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.ElementValue
+elementValueAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ElementValue"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.ElementValueArrayInitializer wrapper
+elementValueArrayInitializer :: Typed.TypedTerm [Syntax.ElementValue] -> Typed.TypedTerm Syntax.ElementValueArrayInitializer
+elementValueArrayInitializer x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ElementValueArrayInitializer"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the conditionalExpression variant of hydra.java.syntax.ElementValue
+elementValueConditionalExpression :: Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.ElementValue
+elementValueConditionalExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ElementValue"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "conditionalExpression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the elementValueArrayInitializer variant of hydra.java.syntax.ElementValue
+elementValueElementValueArrayInitializer :: Typed.TypedTerm Syntax.ElementValueArrayInitializer -> Typed.TypedTerm Syntax.ElementValue
+elementValueElementValueArrayInitializer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ElementValue"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "elementValueArrayInitializer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ElementValuePair
+elementValuePair :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ElementValue -> Typed.TypedTerm Syntax.ElementValuePair
+elementValuePair key value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ElementValuePair"),
+      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.java.syntax.ElementValuePair
+elementValuePairKey :: Typed.TypedTerm Syntax.ElementValuePair -> Typed.TypedTerm Syntax.Identifier
+elementValuePairKey x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ElementValuePair"),
+        Core.projectionFieldName = (Core.Name "key")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.java.syntax.ElementValuePair
+elementValuePairValue :: Typed.TypedTerm Syntax.ElementValuePair -> Typed.TypedTerm Syntax.ElementValue
+elementValuePairValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ElementValuePair"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the key field of hydra.java.syntax.ElementValuePair
+elementValuePairWithKey :: Typed.TypedTerm Syntax.ElementValuePair -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ElementValuePair
+elementValuePairWithKey original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ElementValuePair"),
+      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.java.syntax.ElementValuePair"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.java.syntax.ElementValuePair
+elementValuePairWithValue :: Typed.TypedTerm Syntax.ElementValuePair -> Typed.TypedTerm Syntax.ElementValue -> Typed.TypedTerm Syntax.ElementValuePair
+elementValuePairWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ElementValuePair"),
+      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.java.syntax.ElementValuePair"),
+              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.java.syntax.EnhancedForCond
+enhancedForCond :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.EnhancedForCond
+enhancedForCond declaration expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "declaration"),
+          Core.fieldTerm = (Typed.unTypedTerm declaration)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the declaration field of hydra.java.syntax.EnhancedForCond
+enhancedForCondDeclaration :: Typed.TypedTerm Syntax.EnhancedForCond -> Typed.TypedTerm Syntax.LocalVariableDeclaration
+enhancedForCondDeclaration x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForCond"),
+        Core.projectionFieldName = (Core.Name "declaration")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.EnhancedForCond
+enhancedForCondExpression :: Typed.TypedTerm Syntax.EnhancedForCond -> Typed.TypedTerm Syntax.Expression
+enhancedForCondExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForCond"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the declaration field of hydra.java.syntax.EnhancedForCond
+enhancedForCondWithDeclaration :: Typed.TypedTerm Syntax.EnhancedForCond -> Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.EnhancedForCond
+enhancedForCondWithDeclaration original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "declaration"),
+          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.java.syntax.EnhancedForCond"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.EnhancedForCond
+enhancedForCondWithExpression :: Typed.TypedTerm Syntax.EnhancedForCond -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.EnhancedForCond
+enhancedForCondWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "declaration"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForCond"),
+              Core.projectionFieldName = (Core.Name "declaration")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.EnhancedForStatement
+enhancedForStatement :: Typed.TypedTerm Syntax.EnhancedForCond -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.EnhancedForStatement
+enhancedForStatement cond body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.EnhancedForStatement
+enhancedForStatementBody :: Typed.TypedTerm Syntax.EnhancedForStatement -> Typed.TypedTerm Syntax.Statement
+enhancedForStatementBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatement"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.EnhancedForStatement
+enhancedForStatementCond :: Typed.TypedTerm Syntax.EnhancedForStatement -> Typed.TypedTerm Syntax.EnhancedForCond
+enhancedForStatementCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatement"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.EnhancedForStatementNoShortIf
+enhancedForStatementNoShortIf :: Typed.TypedTerm Syntax.EnhancedForCond -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.EnhancedForStatementNoShortIf
+enhancedForStatementNoShortIf cond body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.EnhancedForStatementNoShortIf
+enhancedForStatementNoShortIfBody :: Typed.TypedTerm Syntax.EnhancedForStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+enhancedForStatementNoShortIfBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.EnhancedForStatementNoShortIf
+enhancedForStatementNoShortIfCond :: Typed.TypedTerm Syntax.EnhancedForStatementNoShortIf -> Typed.TypedTerm Syntax.EnhancedForCond
+enhancedForStatementNoShortIfCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.EnhancedForStatementNoShortIf
+enhancedForStatementNoShortIfWithBody :: Typed.TypedTerm Syntax.EnhancedForStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.EnhancedForStatementNoShortIf
+enhancedForStatementNoShortIfWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.EnhancedForStatementNoShortIf
+enhancedForStatementNoShortIfWithCond :: Typed.TypedTerm Syntax.EnhancedForStatementNoShortIf -> Typed.TypedTerm Syntax.EnhancedForCond -> Typed.TypedTerm Syntax.EnhancedForStatementNoShortIf
+enhancedForStatementNoShortIfWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          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.java.syntax.EnhancedForStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the body field of hydra.java.syntax.EnhancedForStatement
+enhancedForStatementWithBody :: Typed.TypedTerm Syntax.EnhancedForStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.EnhancedForStatement
+enhancedForStatementWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatement"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.EnhancedForStatement
+enhancedForStatementWithCond :: Typed.TypedTerm Syntax.EnhancedForStatement -> Typed.TypedTerm Syntax.EnhancedForCond -> Typed.TypedTerm Syntax.EnhancedForStatement
+enhancedForStatementWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnhancedForStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          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.java.syntax.EnhancedForStatement"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.EnumBody wrapper
+enumBody :: Typed.TypedTerm [Syntax.EnumBody_Element] -> Typed.TypedTerm Syntax.EnumBody
+enumBody x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.EnumBody"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.EnumBody_Element
+enumBody_Element :: Typed.TypedTerm [Syntax.EnumConstant] -> Typed.TypedTerm [Syntax.ClassBodyDeclaration] -> Typed.TypedTerm Syntax.EnumBody_Element
+enumBody_Element constants bodyDeclarations =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumBody_Element"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constants"),
+          Core.fieldTerm = (Typed.unTypedTerm constants)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bodyDeclarations"),
+          Core.fieldTerm = (Typed.unTypedTerm bodyDeclarations)}]}))
+
+-- | DSL accessor for the bodyDeclarations field of hydra.java.syntax.EnumBody_Element
+enumBody_ElementBodyDeclarations :: Typed.TypedTerm Syntax.EnumBody_Element -> Typed.TypedTerm [Syntax.ClassBodyDeclaration]
+enumBody_ElementBodyDeclarations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumBody_Element"),
+        Core.projectionFieldName = (Core.Name "bodyDeclarations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the constants field of hydra.java.syntax.EnumBody_Element
+enumBody_ElementConstants :: Typed.TypedTerm Syntax.EnumBody_Element -> Typed.TypedTerm [Syntax.EnumConstant]
+enumBody_ElementConstants x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumBody_Element"),
+        Core.projectionFieldName = (Core.Name "constants")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the bodyDeclarations field of hydra.java.syntax.EnumBody_Element
+enumBody_ElementWithBodyDeclarations :: Typed.TypedTerm Syntax.EnumBody_Element -> Typed.TypedTerm [Syntax.ClassBodyDeclaration] -> Typed.TypedTerm Syntax.EnumBody_Element
+enumBody_ElementWithBodyDeclarations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumBody_Element"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constants"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumBody_Element"),
+              Core.projectionFieldName = (Core.Name "constants")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bodyDeclarations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the constants field of hydra.java.syntax.EnumBody_Element
+enumBody_ElementWithConstants :: Typed.TypedTerm Syntax.EnumBody_Element -> Typed.TypedTerm [Syntax.EnumConstant] -> Typed.TypedTerm Syntax.EnumBody_Element
+enumBody_ElementWithConstants original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumBody_Element"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "constants"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bodyDeclarations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumBody_Element"),
+              Core.projectionFieldName = (Core.Name "bodyDeclarations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.EnumConstant
+enumConstant :: Typed.TypedTerm [Syntax.EnumConstantModifier] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe [Syntax.Expression]) -> Typed.TypedTerm (Maybe Syntax.ClassBody) -> Typed.TypedTerm Syntax.EnumConstant
+enumConstant modifiers identifier arguments body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm arguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the arguments field of hydra.java.syntax.EnumConstant
+enumConstantArguments :: Typed.TypedTerm Syntax.EnumConstant -> Typed.TypedTerm (Maybe [Syntax.Expression])
+enumConstantArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+        Core.projectionFieldName = (Core.Name "arguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.EnumConstant
+enumConstantBody :: Typed.TypedTerm Syntax.EnumConstant -> Typed.TypedTerm (Maybe Syntax.ClassBody)
+enumConstantBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.EnumConstant
+enumConstantIdentifier :: Typed.TypedTerm Syntax.EnumConstant -> Typed.TypedTerm Syntax.Identifier
+enumConstantIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.EnumConstantModifier wrapper
+enumConstantModifier :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.EnumConstantModifier
+enumConstantModifier x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.EnumConstantModifier"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.EnumConstant
+enumConstantModifiers :: Typed.TypedTerm Syntax.EnumConstant -> Typed.TypedTerm [Syntax.EnumConstantModifier]
+enumConstantModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the arguments field of hydra.java.syntax.EnumConstant
+enumConstantWithArguments :: Typed.TypedTerm Syntax.EnumConstant -> Typed.TypedTerm (Maybe [Syntax.Expression]) -> Typed.TypedTerm Syntax.EnumConstant
+enumConstantWithArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          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.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the body field of hydra.java.syntax.EnumConstant
+enumConstantWithBody :: Typed.TypedTerm Syntax.EnumConstant -> Typed.TypedTerm (Maybe Syntax.ClassBody) -> Typed.TypedTerm Syntax.EnumConstant
+enumConstantWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.EnumConstant
+enumConstantWithIdentifier :: Typed.TypedTerm Syntax.EnumConstant -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.EnumConstant
+enumConstantWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          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.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            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.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.EnumConstant
+enumConstantWithModifiers :: Typed.TypedTerm Syntax.EnumConstant -> Typed.TypedTerm [Syntax.EnumConstantModifier] -> Typed.TypedTerm Syntax.EnumConstant
+enumConstantWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            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.java.syntax.EnumConstant"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.EnumDeclaration
+enumDeclaration :: Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.EnumBody -> Typed.TypedTerm Syntax.EnumDeclaration
+enumDeclaration modifiers identifier implements body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Typed.unTypedTerm implements)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.EnumDeclaration
+enumDeclarationBody :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.EnumBody
+enumDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.EnumDeclaration
+enumDeclarationIdentifier :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier
+enumDeclarationIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the implements field of hydra.java.syntax.EnumDeclaration
+enumDeclarationImplements :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm [Syntax.InterfaceType]
+enumDeclarationImplements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+        Core.projectionFieldName = (Core.Name "implements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.EnumDeclaration
+enumDeclarationModifiers :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm [Syntax.ClassModifier]
+enumDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.EnumDeclaration
+enumDeclarationWithBody :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.EnumBody -> Typed.TypedTerm Syntax.EnumDeclaration
+enumDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.EnumDeclaration
+enumDeclarationWithIdentifier :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.EnumDeclaration
+enumDeclarationWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            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.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the implements field of hydra.java.syntax.EnumDeclaration
+enumDeclarationWithImplements :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.EnumDeclaration
+enumDeclarationWithImplements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          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.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.EnumDeclaration
+enumDeclarationWithModifiers :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Syntax.EnumDeclaration
+enumDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            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.java.syntax.EnumDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the equal variant of hydra.java.syntax.EqualityExpression
+equalityExpressionEqual :: Typed.TypedTerm Syntax.EqualityExpression_Binary -> Typed.TypedTerm Syntax.EqualityExpression
+equalityExpressionEqual x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.EqualityExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "equal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the notEqual variant of hydra.java.syntax.EqualityExpression
+equalityExpressionNotEqual :: Typed.TypedTerm Syntax.EqualityExpression_Binary -> Typed.TypedTerm Syntax.EqualityExpression
+equalityExpressionNotEqual x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.EqualityExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "notEqual"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the unary variant of hydra.java.syntax.EqualityExpression
+equalityExpressionUnary :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualityExpression
+equalityExpressionUnary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.EqualityExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.EqualityExpression_Binary
+equalityExpression_Binary :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualityExpression_Binary
+equalityExpression_Binary lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EqualityExpression_Binary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.EqualityExpression_Binary
+equalityExpression_BinaryLhs :: Typed.TypedTerm Syntax.EqualityExpression_Binary -> Typed.TypedTerm Syntax.EqualityExpression
+equalityExpression_BinaryLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EqualityExpression_Binary"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.EqualityExpression_Binary
+equalityExpression_BinaryRhs :: Typed.TypedTerm Syntax.EqualityExpression_Binary -> Typed.TypedTerm Syntax.RelationalExpression
+equalityExpression_BinaryRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.EqualityExpression_Binary"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.EqualityExpression_Binary
+equalityExpression_BinaryWithLhs :: Typed.TypedTerm Syntax.EqualityExpression_Binary -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.EqualityExpression_Binary
+equalityExpression_BinaryWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EqualityExpression_Binary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.EqualityExpression_Binary"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.EqualityExpression_Binary
+equalityExpression_BinaryWithRhs :: Typed.TypedTerm Syntax.EqualityExpression_Binary -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualityExpression_Binary
+equalityExpression_BinaryWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.EqualityExpression_Binary"),
+      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.java.syntax.EqualityExpression_Binary"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the class variant of hydra.java.syntax.ExceptionType
+exceptionTypeClass :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.ExceptionType
+exceptionTypeClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ExceptionType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variable variant of hydra.java.syntax.ExceptionType
+exceptionTypeVariable :: Typed.TypedTerm Syntax.TypeVariable -> Typed.TypedTerm Syntax.ExceptionType
+exceptionTypeVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ExceptionType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.ExclusiveOrExpression wrapper
+exclusiveOrExpression :: Typed.TypedTerm [Syntax.AndExpression] -> Typed.TypedTerm Syntax.ExclusiveOrExpression
+exclusiveOrExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ExclusiveOrExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.ExplicitConstructorInvocation
+explicitConstructorInvocation :: Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation_Variant -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation
+explicitConstructorInvocation typeArguments arguments variant =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm arguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Typed.unTypedTerm variant)}]}))
+
+-- | DSL accessor for the arguments field of hydra.java.syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationArguments :: Typed.TypedTerm Syntax.ExplicitConstructorInvocation -> Typed.TypedTerm [Syntax.Expression]
+explicitConstructorInvocationArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+        Core.projectionFieldName = (Core.Name "arguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationTypeArguments :: Typed.TypedTerm Syntax.ExplicitConstructorInvocation -> Typed.TypedTerm [Syntax.TypeArgument]
+explicitConstructorInvocationTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the variant field of hydra.java.syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationVariant :: Typed.TypedTerm Syntax.ExplicitConstructorInvocation -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation_Variant
+explicitConstructorInvocationVariant x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+        Core.projectionFieldName = (Core.Name "variant")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the arguments field of hydra.java.syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationWithArguments :: Typed.TypedTerm Syntax.ExplicitConstructorInvocation -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationWithArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+              Core.projectionFieldName = (Core.Name "variant")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationWithTypeArguments :: Typed.TypedTerm Syntax.ExplicitConstructorInvocation -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          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.java.syntax.ExplicitConstructorInvocation"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+              Core.projectionFieldName = (Core.Name "variant")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the variant field of hydra.java.syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationWithVariant :: Typed.TypedTerm Syntax.ExplicitConstructorInvocation -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation_Variant -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation
+explicitConstructorInvocationWithVariant original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the primary variant of hydra.java.syntax.ExplicitConstructorInvocation_Variant
+explicitConstructorInvocation_VariantPrimary :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation_Variant
+explicitConstructorInvocation_VariantPrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the super variant of hydra.java.syntax.ExplicitConstructorInvocation_Variant
+explicitConstructorInvocation_VariantSuper :: Typed.TypedTerm (Maybe Syntax.ExpressionName) -> Typed.TypedTerm Syntax.ExplicitConstructorInvocation_Variant
+explicitConstructorInvocation_VariantSuper x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "super"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the this variant of hydra.java.syntax.ExplicitConstructorInvocation_Variant
+explicitConstructorInvocation_VariantThis :: Typed.TypedTerm Syntax.ExplicitConstructorInvocation_Variant
+explicitConstructorInvocation_VariantThis =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ExplicitConstructorInvocation_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "this"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the assignment variant of hydra.java.syntax.Expression
+expressionAssignment :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Expression
+expressionAssignment x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "assignment"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the lambda variant of hydra.java.syntax.Expression
+expressionLambda :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.Expression
+expressionLambda x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Expression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lambda"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ExpressionName
+expressionName :: Typed.TypedTerm (Maybe Syntax.AmbiguousName) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExpressionName
+expressionName qualifier identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ExpressionName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.ExpressionName
+expressionNameIdentifier :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.Identifier
+expressionNameIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExpressionName"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the qualifier field of hydra.java.syntax.ExpressionName
+expressionNameQualifier :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm (Maybe Syntax.AmbiguousName)
+expressionNameQualifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExpressionName"),
+        Core.projectionFieldName = (Core.Name "qualifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.ExpressionName
+expressionNameWithIdentifier :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExpressionName
+expressionNameWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ExpressionName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExpressionName"),
+              Core.projectionFieldName = (Core.Name "qualifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the qualifier field of hydra.java.syntax.ExpressionName
+expressionNameWithQualifier :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm (Maybe Syntax.AmbiguousName) -> Typed.TypedTerm Syntax.ExpressionName
+expressionNameWithQualifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ExpressionName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ExpressionName"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.ExpressionStatement wrapper
+expressionStatement :: Typed.TypedTerm Syntax.StatementExpression -> Typed.TypedTerm Syntax.ExpressionStatement
+expressionStatement x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ExpressionStatement"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.FieldAccess
+fieldAccess :: Typed.TypedTerm Syntax.FieldAccess_Qualifier -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FieldAccess
+fieldAccess qualifier identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FieldAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.FieldAccess
+fieldAccessIdentifier :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Identifier
+fieldAccessIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldAccess"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the qualifier field of hydra.java.syntax.FieldAccess
+fieldAccessQualifier :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.FieldAccess_Qualifier
+fieldAccessQualifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldAccess"),
+        Core.projectionFieldName = (Core.Name "qualifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.FieldAccess
+fieldAccessWithIdentifier :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FieldAccess
+fieldAccessWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FieldAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldAccess"),
+              Core.projectionFieldName = (Core.Name "qualifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the qualifier field of hydra.java.syntax.FieldAccess
+fieldAccessWithQualifier :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.FieldAccess_Qualifier -> Typed.TypedTerm Syntax.FieldAccess
+fieldAccessWithQualifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FieldAccess"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldAccess"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the primary variant of hydra.java.syntax.FieldAccess_Qualifier
+fieldAccess_QualifierPrimary :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.FieldAccess_Qualifier
+fieldAccess_QualifierPrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldAccess_Qualifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the super variant of hydra.java.syntax.FieldAccess_Qualifier
+fieldAccess_QualifierSuper :: Typed.TypedTerm Syntax.FieldAccess_Qualifier
+fieldAccess_QualifierSuper =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldAccess_Qualifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "super"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the typed variant of hydra.java.syntax.FieldAccess_Qualifier
+fieldAccess_QualifierTyped :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.FieldAccess_Qualifier
+fieldAccess_QualifierTyped x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldAccess_Qualifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typed"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.FieldDeclaration
+fieldDeclaration :: Typed.TypedTerm [Syntax.FieldModifier] -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.FieldDeclaration
+fieldDeclaration modifiers unannType variableDeclarators =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "unannType"),
+          Core.fieldTerm = (Typed.unTypedTerm unannType)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variableDeclarators"),
+          Core.fieldTerm = (Typed.unTypedTerm variableDeclarators)}]}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.FieldDeclaration
+fieldDeclarationModifiers :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.FieldModifier]
+fieldDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the unannType field of hydra.java.syntax.FieldDeclaration
+fieldDeclarationUnannType :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.UnannType
+fieldDeclarationUnannType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+        Core.projectionFieldName = (Core.Name "unannType")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the variableDeclarators field of hydra.java.syntax.FieldDeclaration
+fieldDeclarationVariableDeclarators :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator]
+fieldDeclarationVariableDeclarators x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+        Core.projectionFieldName = (Core.Name "variableDeclarators")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.FieldDeclaration
+fieldDeclarationWithModifiers :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.FieldModifier] -> Typed.TypedTerm Syntax.FieldDeclaration
+fieldDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "unannType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+              Core.projectionFieldName = (Core.Name "unannType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variableDeclarators"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+              Core.projectionFieldName = (Core.Name "variableDeclarators")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the unannType field of hydra.java.syntax.FieldDeclaration
+fieldDeclarationWithUnannType :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.FieldDeclaration
+fieldDeclarationWithUnannType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "unannType"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "variableDeclarators"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+              Core.projectionFieldName = (Core.Name "variableDeclarators")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the variableDeclarators field of hydra.java.syntax.FieldDeclaration
+fieldDeclarationWithVariableDeclarators :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.FieldDeclaration
+fieldDeclarationWithVariableDeclarators original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "unannType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FieldDeclaration"),
+              Core.projectionFieldName = (Core.Name "unannType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "variableDeclarators"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.FieldModifier
+fieldModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.FieldModifier
+fieldModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the final variant of hydra.java.syntax.FieldModifier
+fieldModifierFinal :: Typed.TypedTerm Syntax.FieldModifier
+fieldModifierFinal =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "final"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the private variant of hydra.java.syntax.FieldModifier
+fieldModifierPrivate :: Typed.TypedTerm Syntax.FieldModifier
+fieldModifierPrivate =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "private"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the protected variant of hydra.java.syntax.FieldModifier
+fieldModifierProtected :: Typed.TypedTerm Syntax.FieldModifier
+fieldModifierProtected =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "protected"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the public variant of hydra.java.syntax.FieldModifier
+fieldModifierPublic :: Typed.TypedTerm Syntax.FieldModifier
+fieldModifierPublic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "public"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the static variant of hydra.java.syntax.FieldModifier
+fieldModifierStatic :: Typed.TypedTerm Syntax.FieldModifier
+fieldModifierStatic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "static"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the transient variant of hydra.java.syntax.FieldModifier
+fieldModifierTransient :: Typed.TypedTerm Syntax.FieldModifier
+fieldModifierTransient =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "transient"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the volatile variant of hydra.java.syntax.FieldModifier
+fieldModifierVolatile :: Typed.TypedTerm Syntax.FieldModifier
+fieldModifierVolatile =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FieldModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "volatile"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.java.syntax.Finally wrapper
+finally :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.Finally
+finally x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.Finally"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.FloatingPointLiteral wrapper
+floatingPointLiteral :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.FloatingPointLiteral
+floatingPointLiteral x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.FloatingPointLiteral"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the double variant of hydra.java.syntax.FloatingPointType
+floatingPointTypeDouble :: Typed.TypedTerm Syntax.FloatingPointType
+floatingPointTypeDouble =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FloatingPointType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "double"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the float variant of hydra.java.syntax.FloatingPointType
+floatingPointTypeFloat :: Typed.TypedTerm Syntax.FloatingPointType
+floatingPointTypeFloat =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FloatingPointType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "float"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.java.syntax.ForCond
+forCond :: Typed.TypedTerm (Maybe Syntax.ForInit) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe Syntax.ForUpdate) -> Typed.TypedTerm Syntax.ForCond
+forCond init cond update =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm init)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "update"),
+          Core.fieldTerm = (Typed.unTypedTerm update)}]}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.ForCond
+forCondCond :: Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm (Maybe Syntax.Expression)
+forCondCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the init field of hydra.java.syntax.ForCond
+forCondInit :: Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm (Maybe Syntax.ForInit)
+forCondInit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+        Core.projectionFieldName = (Core.Name "init")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the update field of hydra.java.syntax.ForCond
+forCondUpdate :: Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm (Maybe Syntax.ForUpdate)
+forCondUpdate x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+        Core.projectionFieldName = (Core.Name "update")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.ForCond
+forCondWithCond :: Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.ForCond
+forCondWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+      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.java.syntax.ForCond"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "update"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+              Core.projectionFieldName = (Core.Name "update")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the init field of hydra.java.syntax.ForCond
+forCondWithInit :: Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm (Maybe Syntax.ForInit) -> Typed.TypedTerm Syntax.ForCond
+forCondWithInit original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "update"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+              Core.projectionFieldName = (Core.Name "update")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the update field of hydra.java.syntax.ForCond
+forCondWithUpdate :: Typed.TypedTerm Syntax.ForCond -> Typed.TypedTerm (Maybe Syntax.ForUpdate) -> Typed.TypedTerm Syntax.ForCond
+forCondWithUpdate original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+      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.java.syntax.ForCond"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ForCond"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "update"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the localVariable variant of hydra.java.syntax.ForInit
+forInitLocalVariable :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.ForInit
+forInitLocalVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ForInit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "localVariable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the statements variant of hydra.java.syntax.ForInit
+forInitStatements :: Typed.TypedTerm [Syntax.StatementExpression] -> Typed.TypedTerm Syntax.ForInit
+forInitStatements x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ForInit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "statements"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the basic variant of hydra.java.syntax.ForStatement
+forStatementBasic :: Typed.TypedTerm Syntax.BasicForStatement -> Typed.TypedTerm Syntax.ForStatement
+forStatementBasic x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ForStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "basic"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the enhanced variant of hydra.java.syntax.ForStatement
+forStatementEnhanced :: Typed.TypedTerm Syntax.EnhancedForStatement -> Typed.TypedTerm Syntax.ForStatement
+forStatementEnhanced x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ForStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "enhanced"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the basic variant of hydra.java.syntax.ForStatementNoShortIf
+forStatementNoShortIfBasic :: Typed.TypedTerm Syntax.BasicForStatementNoShortIf -> Typed.TypedTerm Syntax.ForStatementNoShortIf
+forStatementNoShortIfBasic x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ForStatementNoShortIf"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "basic"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the enhanced variant of hydra.java.syntax.ForStatementNoShortIf
+forStatementNoShortIfEnhanced :: Typed.TypedTerm Syntax.EnhancedForStatementNoShortIf -> Typed.TypedTerm Syntax.ForStatementNoShortIf
+forStatementNoShortIfEnhanced x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ForStatementNoShortIf"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "enhanced"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.ForUpdate wrapper
+forUpdate :: Typed.TypedTerm [Syntax.StatementExpression] -> Typed.TypedTerm Syntax.ForUpdate
+forUpdate x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ForUpdate"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.FormalParameter
+formalParameterSimple :: Typed.TypedTerm Syntax.FormalParameter_Simple -> Typed.TypedTerm Syntax.FormalParameter
+formalParameterSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variableArity variant of hydra.java.syntax.FormalParameter
+formalParameterVariableArity :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm Syntax.FormalParameter
+formalParameterVariableArity x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variableArity"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.FormalParameter_Simple
+formalParameter_Simple :: Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.FormalParameter_Simple
+formalParameter_Simple modifiers type_ id =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Typed.unTypedTerm id)}]}))
+
+-- | DSL accessor for the id field of hydra.java.syntax.FormalParameter_Simple
+formalParameter_SimpleId :: Typed.TypedTerm Syntax.FormalParameter_Simple -> Typed.TypedTerm Syntax.VariableDeclaratorId
+formalParameter_SimpleId x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+        Core.projectionFieldName = (Core.Name "id")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.FormalParameter_Simple
+formalParameter_SimpleModifiers :: Typed.TypedTerm Syntax.FormalParameter_Simple -> Typed.TypedTerm [Syntax.VariableModifier]
+formalParameter_SimpleModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.FormalParameter_Simple
+formalParameter_SimpleType :: Typed.TypedTerm Syntax.FormalParameter_Simple -> Typed.TypedTerm Syntax.UnannType
+formalParameter_SimpleType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the id field of hydra.java.syntax.FormalParameter_Simple
+formalParameter_SimpleWithId :: Typed.TypedTerm Syntax.FormalParameter_Simple -> Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.FormalParameter_Simple
+formalParameter_SimpleWithId original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.FormalParameter_Simple"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.FormalParameter_Simple
+formalParameter_SimpleWithModifiers :: Typed.TypedTerm Syntax.FormalParameter_Simple -> Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.FormalParameter_Simple
+formalParameter_SimpleWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.FormalParameter_Simple"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+              Core.projectionFieldName = (Core.Name "id")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.FormalParameter_Simple
+formalParameter_SimpleWithType :: Typed.TypedTerm Syntax.FormalParameter_Simple -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.FormalParameter_Simple
+formalParameter_SimpleWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.FormalParameter_Simple"),
+              Core.projectionFieldName = (Core.Name "id")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.Guard wrapper
+guard :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Guard
+guard x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.Guard"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.Identifier wrapper
+identifier :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Identifier
+identifier x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.Identifier"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.IfThenElseStatement
+ifThenElseStatement :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.IfThenElseStatement
+ifThenElseStatement cond then_ else_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        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 cond field of hydra.java.syntax.IfThenElseStatement
+ifThenElseStatementCond :: Typed.TypedTerm Syntax.IfThenElseStatement -> Typed.TypedTerm (Maybe Syntax.Expression)
+ifThenElseStatementCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the else field of hydra.java.syntax.IfThenElseStatement
+ifThenElseStatementElse :: Typed.TypedTerm Syntax.IfThenElseStatement -> Typed.TypedTerm Syntax.Statement
+ifThenElseStatementElse x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+        Core.projectionFieldName = (Core.Name "else")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIf :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIf cond then_ else_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        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 cond field of hydra.java.syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfCond :: Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf -> Typed.TypedTerm (Maybe Syntax.Expression)
+ifThenElseStatementNoShortIfCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the else field of hydra.java.syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfElse :: Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+ifThenElseStatementNoShortIfElse x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "else")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the then field of hydra.java.syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfThen :: Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+ifThenElseStatementNoShortIfThen x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "then")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfWithCond :: Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          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.java.syntax.IfThenElseStatementNoShortIf"),
+              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.java.syntax.IfThenElseStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the else field of hydra.java.syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfWithElse :: Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfWithElse original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            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.java.syntax.IfThenElseStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "then")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "else"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the then field of hydra.java.syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfWithThen :: Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf
+ifThenElseStatementNoShortIfWithThen original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            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.java.syntax.IfThenElseStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL accessor for the then field of hydra.java.syntax.IfThenElseStatement
+ifThenElseStatementThen :: Typed.TypedTerm Syntax.IfThenElseStatement -> Typed.TypedTerm Syntax.StatementNoShortIf
+ifThenElseStatementThen x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+        Core.projectionFieldName = (Core.Name "then")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.IfThenElseStatement
+ifThenElseStatementWithCond :: Typed.TypedTerm Syntax.IfThenElseStatement -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.IfThenElseStatement
+ifThenElseStatementWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          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.java.syntax.IfThenElseStatement"),
+              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.java.syntax.IfThenElseStatement"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the else field of hydra.java.syntax.IfThenElseStatement
+ifThenElseStatementWithElse :: Typed.TypedTerm Syntax.IfThenElseStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.IfThenElseStatement
+ifThenElseStatementWithElse original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            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.java.syntax.IfThenElseStatement"),
+              Core.projectionFieldName = (Core.Name "then")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "else"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the then field of hydra.java.syntax.IfThenElseStatement
+ifThenElseStatementWithThen :: Typed.TypedTerm Syntax.IfThenElseStatement -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.IfThenElseStatement
+ifThenElseStatementWithThen original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenElseStatement"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            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.java.syntax.IfThenElseStatement"),
+              Core.projectionFieldName = (Core.Name "else")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.IfThenStatement
+ifThenStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.IfThenStatement
+ifThenStatement expression statement =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Typed.unTypedTerm statement)}]}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.IfThenStatement
+ifThenStatementExpression :: Typed.TypedTerm Syntax.IfThenStatement -> Typed.TypedTerm Syntax.Expression
+ifThenStatementExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenStatement"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the statement field of hydra.java.syntax.IfThenStatement
+ifThenStatementStatement :: Typed.TypedTerm Syntax.IfThenStatement -> Typed.TypedTerm Syntax.Statement
+ifThenStatementStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.IfThenStatement"),
+        Core.projectionFieldName = (Core.Name "statement")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.IfThenStatement
+ifThenStatementWithExpression :: Typed.TypedTerm Syntax.IfThenStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IfThenStatement
+ifThenStatementWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          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.java.syntax.IfThenStatement"),
+              Core.projectionFieldName = (Core.Name "statement")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statement field of hydra.java.syntax.IfThenStatement
+ifThenStatementWithStatement :: Typed.TypedTerm Syntax.IfThenStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.IfThenStatement
+ifThenStatementWithStatement original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.IfThenStatement"),
+      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.java.syntax.IfThenStatement"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the singleStaticImport variant of hydra.java.syntax.ImportDeclaration
+importDeclarationSingleStaticImport :: Typed.TypedTerm Syntax.SingleStaticImportDeclaration -> Typed.TypedTerm Syntax.ImportDeclaration
+importDeclarationSingleStaticImport x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ImportDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "singleStaticImport"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the singleType variant of hydra.java.syntax.ImportDeclaration
+importDeclarationSingleType :: Typed.TypedTerm Syntax.SingleTypeImportDeclaration -> Typed.TypedTerm Syntax.ImportDeclaration
+importDeclarationSingleType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ImportDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "singleType"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the staticImportOnDemand variant of hydra.java.syntax.ImportDeclaration
+importDeclarationStaticImportOnDemand :: Typed.TypedTerm Syntax.StaticImportOnDemandDeclaration -> Typed.TypedTerm Syntax.ImportDeclaration
+importDeclarationStaticImportOnDemand x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ImportDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "staticImportOnDemand"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the typeImportOnDemand variant of hydra.java.syntax.ImportDeclaration
+importDeclarationTypeImportOnDemand :: Typed.TypedTerm Syntax.TypeImportOnDemandDeclaration -> Typed.TypedTerm Syntax.ImportDeclaration
+importDeclarationTypeImportOnDemand x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ImportDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typeImportOnDemand"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.InclusiveOrExpression wrapper
+inclusiveOrExpression :: Typed.TypedTerm [Syntax.ExclusiveOrExpression] -> Typed.TypedTerm Syntax.InclusiveOrExpression
+inclusiveOrExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.InclusiveOrExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.InstanceInitializer wrapper
+instanceInitializer :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.InstanceInitializer
+instanceInitializer x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.InstanceInitializer"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.InstanceofExpression
+instanceofExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.InstanceofExpression_Rhs -> Typed.TypedTerm Syntax.InstanceofExpression
+instanceofExpression lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InstanceofExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.InstanceofExpression
+instanceofExpressionLhs :: Typed.TypedTerm Syntax.InstanceofExpression -> Typed.TypedTerm Syntax.RelationalExpression
+instanceofExpressionLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.InstanceofExpression"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.InstanceofExpression
+instanceofExpressionRhs :: Typed.TypedTerm Syntax.InstanceofExpression -> Typed.TypedTerm Syntax.InstanceofExpression_Rhs
+instanceofExpressionRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.InstanceofExpression"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.InstanceofExpression
+instanceofExpressionWithLhs :: Typed.TypedTerm Syntax.InstanceofExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.InstanceofExpression
+instanceofExpressionWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InstanceofExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.InstanceofExpression"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.InstanceofExpression
+instanceofExpressionWithRhs :: Typed.TypedTerm Syntax.InstanceofExpression -> Typed.TypedTerm Syntax.InstanceofExpression_Rhs -> Typed.TypedTerm Syntax.InstanceofExpression
+instanceofExpressionWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InstanceofExpression"),
+      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.java.syntax.InstanceofExpression"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the pattern variant of hydra.java.syntax.InstanceofExpression_Rhs
+instanceofExpression_RhsPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.InstanceofExpression_Rhs
+instanceofExpression_RhsPattern x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InstanceofExpression_Rhs"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "pattern"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the referenceType variant of hydra.java.syntax.InstanceofExpression_Rhs
+instanceofExpression_RhsReferenceType :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.InstanceofExpression_Rhs
+instanceofExpression_RhsReferenceType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InstanceofExpression_Rhs"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "referenceType"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.IntegerLiteral wrapper
+integerLiteral :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.IntegerLiteral
+integerLiteral x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.IntegerLiteral"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the byte variant of hydra.java.syntax.IntegralType
+integralTypeByte :: Typed.TypedTerm Syntax.IntegralType
+integralTypeByte =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.IntegralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "byte"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the char variant of hydra.java.syntax.IntegralType
+integralTypeChar :: Typed.TypedTerm Syntax.IntegralType
+integralTypeChar =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.IntegralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "char"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the int variant of hydra.java.syntax.IntegralType
+integralTypeInt :: Typed.TypedTerm Syntax.IntegralType
+integralTypeInt =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.IntegralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "int"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the long variant of hydra.java.syntax.IntegralType
+integralTypeLong :: Typed.TypedTerm Syntax.IntegralType
+integralTypeLong =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.IntegralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "long"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the short variant of hydra.java.syntax.IntegralType
+integralTypeShort :: Typed.TypedTerm Syntax.IntegralType
+integralTypeShort =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.IntegralType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "short"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.java.syntax.InterfaceBody wrapper
+interfaceBody :: Typed.TypedTerm [Syntax.InterfaceMemberDeclarationWithComments] -> Typed.TypedTerm Syntax.InterfaceBody
+interfaceBody x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.InterfaceBody"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the annotationInterface variant of hydra.java.syntax.InterfaceDeclaration
+interfaceDeclarationAnnotationInterface :: Typed.TypedTerm Syntax.AnnotationInterfaceDeclaration -> Typed.TypedTerm Syntax.InterfaceDeclaration
+interfaceDeclarationAnnotationInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotationInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the normalInterface variant of hydra.java.syntax.InterfaceDeclaration
+interfaceDeclarationNormalInterface :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm Syntax.InterfaceDeclaration
+interfaceDeclarationNormalInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "normalInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the class variant of hydra.java.syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the constant variant of hydra.java.syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationConstant :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationConstant x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "constant"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interface variant of hydra.java.syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationInterface :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interfaceMethod variant of hydra.java.syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationInterfaceMethod :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationInterfaceMethod x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interfaceMethod"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.InterfaceMemberDeclarationWithComments
+interfaceMemberDeclarationWithComments :: Typed.TypedTerm Syntax.InterfaceMemberDeclaration -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.InterfaceMemberDeclarationWithComments
+interfaceMemberDeclarationWithComments value comments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Typed.unTypedTerm comments)}]}))
+
+-- | DSL accessor for the comments field of hydra.java.syntax.InterfaceMemberDeclarationWithComments
+interfaceMemberDeclarationWithCommentsComments :: Typed.TypedTerm Syntax.InterfaceMemberDeclarationWithComments -> Typed.TypedTerm (Maybe String)
+interfaceMemberDeclarationWithCommentsComments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"),
+        Core.projectionFieldName = (Core.Name "comments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.java.syntax.InterfaceMemberDeclarationWithComments
+interfaceMemberDeclarationWithCommentsValue :: Typed.TypedTerm Syntax.InterfaceMemberDeclarationWithComments -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
+interfaceMemberDeclarationWithCommentsValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the comments field of hydra.java.syntax.InterfaceMemberDeclarationWithComments
+interfaceMemberDeclarationWithCommentsWithComments :: Typed.TypedTerm Syntax.InterfaceMemberDeclarationWithComments -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.InterfaceMemberDeclarationWithComments
+interfaceMemberDeclarationWithCommentsWithComments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the value field of hydra.java.syntax.InterfaceMemberDeclarationWithComments
+interfaceMemberDeclarationWithCommentsWithValue :: Typed.TypedTerm Syntax.InterfaceMemberDeclarationWithComments -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclarationWithComments
+interfaceMemberDeclarationWithCommentsWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"),
+              Core.projectionFieldName = (Core.Name "comments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.InterfaceMethodDeclaration
+interfaceMethodDeclaration :: Typed.TypedTerm [Syntax.InterfaceMethodModifier] -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MethodBody -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
+interfaceMethodDeclaration modifiers header body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Typed.unTypedTerm header)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationBody :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.MethodBody
+interfaceMethodDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the header field of hydra.java.syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationHeader :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader
+interfaceMethodDeclarationHeader x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+        Core.projectionFieldName = (Core.Name "header")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationModifiers :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm [Syntax.InterfaceMethodModifier]
+interfaceMethodDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationWithBody :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.MethodBody -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the header field of hydra.java.syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationWithHeader :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationWithHeader original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          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.java.syntax.InterfaceMethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationWithModifiers :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm [Syntax.InterfaceMethodModifier] -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
+interfaceMethodDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            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.java.syntax.InterfaceMethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the abstract variant of hydra.java.syntax.InterfaceMethodModifier
+interfaceMethodModifierAbstract :: Typed.TypedTerm Syntax.InterfaceMethodModifier
+interfaceMethodModifierAbstract =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "abstract"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.InterfaceMethodModifier
+interfaceMethodModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.InterfaceMethodModifier
+interfaceMethodModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the default variant of hydra.java.syntax.InterfaceMethodModifier
+interfaceMethodModifierDefault :: Typed.TypedTerm Syntax.InterfaceMethodModifier
+interfaceMethodModifierDefault =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "default"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the private variant of hydra.java.syntax.InterfaceMethodModifier
+interfaceMethodModifierPrivate :: Typed.TypedTerm Syntax.InterfaceMethodModifier
+interfaceMethodModifierPrivate =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "private"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the public variant of hydra.java.syntax.InterfaceMethodModifier
+interfaceMethodModifierPublic :: Typed.TypedTerm Syntax.InterfaceMethodModifier
+interfaceMethodModifierPublic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "public"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the static variant of hydra.java.syntax.InterfaceMethodModifier
+interfaceMethodModifierStatic :: Typed.TypedTerm Syntax.InterfaceMethodModifier
+interfaceMethodModifierStatic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "static"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the strictfp variant of hydra.java.syntax.InterfaceMethodModifier
+interfaceMethodModifierStrictfp :: Typed.TypedTerm Syntax.InterfaceMethodModifier
+interfaceMethodModifierStrictfp =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceMethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "strictfp"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the abstract variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierAbstract :: Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierAbstract =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "abstract"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the nonSealed variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierNonSealed :: Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierNonSealed =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "nonSealed"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the private variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierPrivate :: Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierPrivate =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "private"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the protected variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierProtected :: Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierProtected =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "protected"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the public variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierPublic :: Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierPublic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "public"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the sealed variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierSealed :: Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierSealed =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "sealed"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the static variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierStatic :: Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierStatic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "static"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the strictfp variant of hydra.java.syntax.InterfaceModifier
+interfaceModifierStrictfp :: Typed.TypedTerm Syntax.InterfaceModifier
+interfaceModifierStrictfp =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.InterfaceModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "strictfp"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.java.syntax.InterfaceType wrapper
+interfaceType :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.InterfaceType
+interfaceType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.InterfaceType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.LabeledStatement
+labeledStatement :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement
+labeledStatement identifier statement =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LabeledStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Typed.unTypedTerm statement)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.LabeledStatement
+labeledStatementIdentifier :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Identifier
+labeledStatementIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LabeledStatement"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.LabeledStatementNoShortIf
+labeledStatementNoShortIf :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.LabeledStatementNoShortIf
+labeledStatementNoShortIf identifier statement =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LabeledStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Typed.unTypedTerm statement)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.LabeledStatementNoShortIf
+labeledStatementNoShortIfIdentifier :: Typed.TypedTerm Syntax.LabeledStatementNoShortIf -> Typed.TypedTerm Syntax.Identifier
+labeledStatementNoShortIfIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LabeledStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the statement field of hydra.java.syntax.LabeledStatementNoShortIf
+labeledStatementNoShortIfStatement :: Typed.TypedTerm Syntax.LabeledStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+labeledStatementNoShortIfStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LabeledStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "statement")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.LabeledStatementNoShortIf
+labeledStatementNoShortIfWithIdentifier :: Typed.TypedTerm Syntax.LabeledStatementNoShortIf -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LabeledStatementNoShortIf
+labeledStatementNoShortIfWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LabeledStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          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.java.syntax.LabeledStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "statement")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statement field of hydra.java.syntax.LabeledStatementNoShortIf
+labeledStatementNoShortIfWithStatement :: Typed.TypedTerm Syntax.LabeledStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.LabeledStatementNoShortIf
+labeledStatementNoShortIfWithStatement original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LabeledStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LabeledStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL accessor for the statement field of hydra.java.syntax.LabeledStatement
+labeledStatementStatement :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement
+labeledStatementStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LabeledStatement"),
+        Core.projectionFieldName = (Core.Name "statement")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.LabeledStatement
+labeledStatementWithIdentifier :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LabeledStatement
+labeledStatementWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LabeledStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          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.java.syntax.LabeledStatement"),
+              Core.projectionFieldName = (Core.Name "statement")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statement field of hydra.java.syntax.LabeledStatement
+labeledStatementWithStatement :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement
+labeledStatementWithStatement original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LabeledStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LabeledStatement"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statement"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the block variant of hydra.java.syntax.LambdaBody
+lambdaBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.LambdaBody
+lambdaBodyBlock x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LambdaBody"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "block"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the expression variant of hydra.java.syntax.LambdaBody
+lambdaBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LambdaBody
+lambdaBodyExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LambdaBody"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.LambdaExpression
+lambdaExpression :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm Syntax.LambdaBody -> Typed.TypedTerm Syntax.LambdaExpression
+lambdaExpression parameters body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LambdaExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm parameters)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.LambdaExpression
+lambdaExpressionBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.LambdaBody
+lambdaExpressionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaExpression"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parameters field of hydra.java.syntax.LambdaExpression
+lambdaExpressionParameters :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.LambdaParameters
+lambdaExpressionParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaExpression"),
+        Core.projectionFieldName = (Core.Name "parameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.LambdaExpression
+lambdaExpressionWithBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.LambdaBody -> Typed.TypedTerm Syntax.LambdaExpression
+lambdaExpressionWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LambdaExpression"),
+      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.java.syntax.LambdaExpression"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the parameters field of hydra.java.syntax.LambdaExpression
+lambdaExpressionWithParameters :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm Syntax.LambdaExpression
+lambdaExpressionWithParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LambdaExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          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.java.syntax.LambdaExpression"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the normal variant of hydra.java.syntax.LambdaParameter
+lambdaParameterNormal :: Typed.TypedTerm Syntax.LambdaParameter_Normal -> Typed.TypedTerm Syntax.LambdaParameter
+lambdaParameterNormal x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "normal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.java.syntax.LambdaParameterType
+lambdaParameterTypeType :: Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.LambdaParameterType
+lambdaParameterTypeType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameterType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the var variant of hydra.java.syntax.LambdaParameterType
+lambdaParameterTypeVar :: Typed.TypedTerm Syntax.LambdaParameterType
+lambdaParameterTypeVar =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameterType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "var"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the variableArity variant of hydra.java.syntax.LambdaParameter
+lambdaParameterVariableArity :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm Syntax.LambdaParameter
+lambdaParameterVariableArity x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variableArity"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.LambdaParameter_Normal
+lambdaParameter_Normal :: Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.LambdaParameterType -> Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.LambdaParameter_Normal
+lambdaParameter_Normal modifiers type_ id =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Typed.unTypedTerm id)}]}))
+
+-- | DSL accessor for the id field of hydra.java.syntax.LambdaParameter_Normal
+lambdaParameter_NormalId :: Typed.TypedTerm Syntax.LambdaParameter_Normal -> Typed.TypedTerm Syntax.VariableDeclaratorId
+lambdaParameter_NormalId x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+        Core.projectionFieldName = (Core.Name "id")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.LambdaParameter_Normal
+lambdaParameter_NormalModifiers :: Typed.TypedTerm Syntax.LambdaParameter_Normal -> Typed.TypedTerm [Syntax.VariableModifier]
+lambdaParameter_NormalModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.LambdaParameter_Normal
+lambdaParameter_NormalType :: Typed.TypedTerm Syntax.LambdaParameter_Normal -> Typed.TypedTerm Syntax.LambdaParameterType
+lambdaParameter_NormalType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the id field of hydra.java.syntax.LambdaParameter_Normal
+lambdaParameter_NormalWithId :: Typed.TypedTerm Syntax.LambdaParameter_Normal -> Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.LambdaParameter_Normal
+lambdaParameter_NormalWithId original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.LambdaParameter_Normal"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.LambdaParameter_Normal
+lambdaParameter_NormalWithModifiers :: Typed.TypedTerm Syntax.LambdaParameter_Normal -> Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.LambdaParameter_Normal
+lambdaParameter_NormalWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.LambdaParameter_Normal"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+              Core.projectionFieldName = (Core.Name "id")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.LambdaParameter_Normal
+lambdaParameter_NormalWithType :: Typed.TypedTerm Syntax.LambdaParameter_Normal -> Typed.TypedTerm Syntax.LambdaParameterType -> Typed.TypedTerm Syntax.LambdaParameter_Normal
+lambdaParameter_NormalWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameter_Normal"),
+              Core.projectionFieldName = (Core.Name "id")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the single variant of hydra.java.syntax.LambdaParameters
+lambdaParametersSingle :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LambdaParameters
+lambdaParametersSingle x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameters"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "single"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the tuple variant of hydra.java.syntax.LambdaParameters
+lambdaParametersTuple :: Typed.TypedTerm [Syntax.LambdaParameters] -> Typed.TypedTerm Syntax.LambdaParameters
+lambdaParametersTuple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LambdaParameters"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "tuple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the arrayAccess variant of hydra.java.syntax.LeftHandSide
+leftHandSideArrayAccess :: Typed.TypedTerm Syntax.ArrayAccess -> Typed.TypedTerm Syntax.LeftHandSide
+leftHandSideArrayAccess x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LeftHandSide"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "arrayAccess"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the expressionName variant of hydra.java.syntax.LeftHandSide
+leftHandSideExpressionName :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.LeftHandSide
+leftHandSideExpressionName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LeftHandSide"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expressionName"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the fieldAccess variant of hydra.java.syntax.LeftHandSide
+leftHandSideFieldAccess :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.LeftHandSide
+leftHandSideFieldAccess x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LeftHandSide"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "fieldAccess"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the boolean variant of hydra.java.syntax.Literal
+literalBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Literal
+literalBoolean x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "boolean"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the character variant of hydra.java.syntax.Literal
+literalCharacter :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.Literal
+literalCharacter x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "character"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the floatingPoint variant of hydra.java.syntax.Literal
+literalFloatingPoint :: Typed.TypedTerm Syntax.FloatingPointLiteral -> Typed.TypedTerm Syntax.Literal
+literalFloatingPoint x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "floatingPoint"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the integer variant of hydra.java.syntax.Literal
+literalInteger :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Syntax.Literal
+literalInteger x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "integer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the null variant of hydra.java.syntax.Literal
+literalNull :: Typed.TypedTerm Syntax.Literal
+literalNull =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "null"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the string variant of hydra.java.syntax.Literal
+literalString :: Typed.TypedTerm Syntax.StringLiteral -> Typed.TypedTerm Syntax.Literal
+literalString x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "string"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the textBlock variant of hydra.java.syntax.Literal
+literalTextBlock :: Typed.TypedTerm Syntax.TextBlock -> Typed.TypedTerm Syntax.Literal
+literalTextBlock x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Literal"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "textBlock"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the class variant of hydra.java.syntax.LocalClassOrInterfaceDeclaration
+localClassOrInterfaceDeclarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.LocalClassOrInterfaceDeclaration
+localClassOrInterfaceDeclarationClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LocalClassOrInterfaceDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the normalInterface variant of hydra.java.syntax.LocalClassOrInterfaceDeclaration
+localClassOrInterfaceDeclarationNormalInterface :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm Syntax.LocalClassOrInterfaceDeclaration
+localClassOrInterfaceDeclarationNormalInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LocalClassOrInterfaceDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "normalInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.LocalVariableDeclaration
+localVariableDeclaration :: Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.LocalVariableDeclaration
+localVariableDeclaration modifiers type_ declarators =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarators"),
+          Core.fieldTerm = (Typed.unTypedTerm declarators)}]}))
+
+-- | DSL accessor for the declarators field of hydra.java.syntax.LocalVariableDeclaration
+localVariableDeclarationDeclarators :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator]
+localVariableDeclarationDeclarators x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+        Core.projectionFieldName = (Core.Name "declarators")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.LocalVariableDeclaration
+localVariableDeclarationModifiers :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm [Syntax.VariableModifier]
+localVariableDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.LocalVariableDeclarationStatement wrapper
+localVariableDeclarationStatement :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableDeclarationStatement
+localVariableDeclarationStatement x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclarationStatement"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.LocalVariableDeclaration
+localVariableDeclarationType :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableType
+localVariableDeclarationType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the declarators field of hydra.java.syntax.LocalVariableDeclaration
+localVariableDeclarationWithDeclarators :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.LocalVariableDeclaration
+localVariableDeclarationWithDeclarators original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.LocalVariableDeclaration"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarators"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.LocalVariableDeclaration
+localVariableDeclarationWithModifiers :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.LocalVariableDeclaration
+localVariableDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.LocalVariableDeclaration"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarators"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+              Core.projectionFieldName = (Core.Name "declarators")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.LocalVariableDeclaration
+localVariableDeclarationWithType :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.LocalVariableDeclaration
+localVariableDeclarationWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarators"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableDeclaration"),
+              Core.projectionFieldName = (Core.Name "declarators")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the type variant of hydra.java.syntax.LocalVariableType
+localVariableTypeType :: Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.LocalVariableType
+localVariableTypeType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the var variant of hydra.java.syntax.LocalVariableType
+localVariableTypeVar :: Typed.TypedTerm Syntax.LocalVariableType
+localVariableTypeVar =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.LocalVariableType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "var"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.java.syntax.MarkerAnnotation wrapper
+markerAnnotation :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.MarkerAnnotation
+markerAnnotation x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.MarkerAnnotation"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the block variant of hydra.java.syntax.MethodBody
+methodBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.MethodBody
+methodBodyBlock x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodBody"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "block"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the none variant of hydra.java.syntax.MethodBody
+methodBodyNone :: Typed.TypedTerm Syntax.MethodBody
+methodBodyNone =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodBody"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "none"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.java.syntax.MethodDeclaration
+methodDeclaration :: Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MethodBody -> Typed.TypedTerm Syntax.MethodDeclaration
+methodDeclaration annotations modifiers header body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Typed.unTypedTerm header)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.MethodDeclaration
+methodDeclarationAnnotations :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm [Syntax.Annotation]
+methodDeclarationAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.MethodDeclaration
+methodDeclarationBody :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.MethodBody
+methodDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the header field of hydra.java.syntax.MethodDeclaration
+methodDeclarationHeader :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader
+methodDeclarationHeader x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+        Core.projectionFieldName = (Core.Name "header")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.MethodDeclaration
+methodDeclarationModifiers :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm [Syntax.MethodModifier]
+methodDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.MethodDeclaration
+methodDeclarationWithAnnotations :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.MethodDeclaration
+methodDeclarationWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            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.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the body field of hydra.java.syntax.MethodDeclaration
+methodDeclarationWithBody :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.MethodBody -> Typed.TypedTerm Syntax.MethodDeclaration
+methodDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the header field of hydra.java.syntax.MethodDeclaration
+methodDeclarationWithHeader :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MethodDeclaration
+methodDeclarationWithHeader original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          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.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.MethodDeclaration
+methodDeclarationWithModifiers :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Syntax.MethodDeclaration
+methodDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            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.java.syntax.MethodDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.MethodDeclarator
+methodDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.ReceiverParameter) -> Typed.TypedTerm [Syntax.FormalParameter] -> Typed.TypedTerm Syntax.MethodDeclarator
+methodDeclarator identifier receiverParameter formalParameters =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Typed.unTypedTerm receiverParameter)},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Typed.unTypedTerm formalParameters)}]}))
+
+-- | DSL accessor for the formalParameters field of hydra.java.syntax.MethodDeclarator
+methodDeclaratorFormalParameters :: Typed.TypedTerm Syntax.MethodDeclarator -> Typed.TypedTerm [Syntax.FormalParameter]
+methodDeclaratorFormalParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+        Core.projectionFieldName = (Core.Name "formalParameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.MethodDeclarator
+methodDeclaratorIdentifier :: Typed.TypedTerm Syntax.MethodDeclarator -> Typed.TypedTerm Syntax.Identifier
+methodDeclaratorIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the receiverParameter field of hydra.java.syntax.MethodDeclarator
+methodDeclaratorReceiverParameter :: Typed.TypedTerm Syntax.MethodDeclarator -> Typed.TypedTerm (Maybe Syntax.ReceiverParameter)
+methodDeclaratorReceiverParameter x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+        Core.projectionFieldName = (Core.Name "receiverParameter")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the formalParameters field of hydra.java.syntax.MethodDeclarator
+methodDeclaratorWithFormalParameters :: Typed.TypedTerm Syntax.MethodDeclarator -> Typed.TypedTerm [Syntax.FormalParameter] -> Typed.TypedTerm Syntax.MethodDeclarator
+methodDeclaratorWithFormalParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+              Core.projectionFieldName = (Core.Name "receiverParameter")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.MethodDeclarator
+methodDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.MethodDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodDeclarator
+methodDeclaratorWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+              Core.projectionFieldName = (Core.Name "receiverParameter")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+              Core.projectionFieldName = (Core.Name "formalParameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the receiverParameter field of hydra.java.syntax.MethodDeclarator
+methodDeclaratorWithReceiverParameter :: Typed.TypedTerm Syntax.MethodDeclarator -> Typed.TypedTerm (Maybe Syntax.ReceiverParameter) -> Typed.TypedTerm Syntax.MethodDeclarator
+methodDeclaratorWithReceiverParameter original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "receiverParameter"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "formalParameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodDeclarator"),
+              Core.projectionFieldName = (Core.Name "formalParameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.MethodHeader
+methodHeader :: Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.Result -> Typed.TypedTerm Syntax.MethodDeclarator -> Typed.TypedTerm (Maybe Syntax.Throws) -> Typed.TypedTerm Syntax.MethodHeader
+methodHeader parameters result declarator throws =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+      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)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarator"),
+          Core.fieldTerm = (Typed.unTypedTerm declarator)},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Typed.unTypedTerm throws)}]}))
+
+-- | DSL accessor for the declarator field of hydra.java.syntax.MethodHeader
+methodHeaderDeclarator :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MethodDeclarator
+methodHeaderDeclarator x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+        Core.projectionFieldName = (Core.Name "declarator")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parameters field of hydra.java.syntax.MethodHeader
+methodHeaderParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm [Syntax.TypeParameter]
+methodHeaderParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+        Core.projectionFieldName = (Core.Name "parameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the result field of hydra.java.syntax.MethodHeader
+methodHeaderResult :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.Result
+methodHeaderResult x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+        Core.projectionFieldName = (Core.Name "result")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the throws field of hydra.java.syntax.MethodHeader
+methodHeaderThrows :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.Throws)
+methodHeaderThrows x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+        Core.projectionFieldName = (Core.Name "throws")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the declarator field of hydra.java.syntax.MethodHeader
+methodHeaderWithDeclarator :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MethodDeclarator -> Typed.TypedTerm Syntax.MethodHeader
+methodHeaderWithDeclarator original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+      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.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "result"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "result")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarator"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "throws")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the parameters field of hydra.java.syntax.MethodHeader
+methodHeaderWithParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.MethodHeader
+methodHeaderWithParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+      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.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "result")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarator"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "declarator")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "throws")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the result field of hydra.java.syntax.MethodHeader
+methodHeaderWithResult :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.Result -> Typed.TypedTerm Syntax.MethodHeader
+methodHeaderWithResult original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+      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.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "result"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarator"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "declarator")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "throws")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the throws field of hydra.java.syntax.MethodHeader
+methodHeaderWithThrows :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.Throws) -> Typed.TypedTerm Syntax.MethodHeader
+methodHeaderWithThrows original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+      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.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "result"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "result")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "declarator"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodHeader"),
+              Core.projectionFieldName = (Core.Name "declarator")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "throws"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.MethodInvocation
+methodInvocation :: Typed.TypedTerm Syntax.MethodInvocation_Header -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.MethodInvocation
+methodInvocation header arguments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodInvocation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Typed.unTypedTerm header)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm arguments)}]}))
+
+-- | DSL accessor for the arguments field of hydra.java.syntax.MethodInvocation
+methodInvocationArguments :: Typed.TypedTerm Syntax.MethodInvocation -> Typed.TypedTerm [Syntax.Expression]
+methodInvocationArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation"),
+        Core.projectionFieldName = (Core.Name "arguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the header field of hydra.java.syntax.MethodInvocation
+methodInvocationHeader :: Typed.TypedTerm Syntax.MethodInvocation -> Typed.TypedTerm Syntax.MethodInvocation_Header
+methodInvocationHeader x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation"),
+        Core.projectionFieldName = (Core.Name "header")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the arguments field of hydra.java.syntax.MethodInvocation
+methodInvocationWithArguments :: Typed.TypedTerm Syntax.MethodInvocation -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.MethodInvocation
+methodInvocationWithArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodInvocation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the header field of hydra.java.syntax.MethodInvocation
+methodInvocationWithHeader :: Typed.TypedTerm Syntax.MethodInvocation -> Typed.TypedTerm Syntax.MethodInvocation_Header -> Typed.TypedTerm Syntax.MethodInvocation
+methodInvocationWithHeader original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodInvocation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          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.java.syntax.MethodInvocation"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.MethodInvocation_Complex
+methodInvocation_Complex :: Typed.TypedTerm Syntax.MethodInvocation_Variant -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodInvocation_Complex
+methodInvocation_Complex variant typeArguments identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Typed.unTypedTerm variant)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.MethodInvocation_Complex
+methodInvocation_ComplexIdentifier :: Typed.TypedTerm Syntax.MethodInvocation_Complex -> Typed.TypedTerm Syntax.Identifier
+methodInvocation_ComplexIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.MethodInvocation_Complex
+methodInvocation_ComplexTypeArguments :: Typed.TypedTerm Syntax.MethodInvocation_Complex -> Typed.TypedTerm [Syntax.TypeArgument]
+methodInvocation_ComplexTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the variant field of hydra.java.syntax.MethodInvocation_Complex
+methodInvocation_ComplexVariant :: Typed.TypedTerm Syntax.MethodInvocation_Complex -> Typed.TypedTerm Syntax.MethodInvocation_Variant
+methodInvocation_ComplexVariant x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+        Core.projectionFieldName = (Core.Name "variant")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.MethodInvocation_Complex
+methodInvocation_ComplexWithIdentifier :: Typed.TypedTerm Syntax.MethodInvocation_Complex -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodInvocation_Complex
+methodInvocation_ComplexWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+              Core.projectionFieldName = (Core.Name "variant")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.MethodInvocation_Complex
+methodInvocation_ComplexWithTypeArguments :: Typed.TypedTerm Syntax.MethodInvocation_Complex -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.MethodInvocation_Complex
+methodInvocation_ComplexWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+              Core.projectionFieldName = (Core.Name "variant")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the variant field of hydra.java.syntax.MethodInvocation_Complex
+methodInvocation_ComplexWithVariant :: Typed.TypedTerm Syntax.MethodInvocation_Complex -> Typed.TypedTerm Syntax.MethodInvocation_Variant -> Typed.TypedTerm Syntax.MethodInvocation_Complex
+methodInvocation_ComplexWithVariant original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "variant"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Complex"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the complex variant of hydra.java.syntax.MethodInvocation_Header
+methodInvocation_HeaderComplex :: Typed.TypedTerm Syntax.MethodInvocation_Complex -> Typed.TypedTerm Syntax.MethodInvocation_Header
+methodInvocation_HeaderComplex x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Header"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "complex"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.MethodInvocation_Header
+methodInvocation_HeaderSimple :: Typed.TypedTerm Syntax.MethodName -> Typed.TypedTerm Syntax.MethodInvocation_Header
+methodInvocation_HeaderSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Header"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the expression variant of hydra.java.syntax.MethodInvocation_Variant
+methodInvocation_VariantExpression :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.MethodInvocation_Variant
+methodInvocation_VariantExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primary variant of hydra.java.syntax.MethodInvocation_Variant
+methodInvocation_VariantPrimary :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.MethodInvocation_Variant
+methodInvocation_VariantPrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the super variant of hydra.java.syntax.MethodInvocation_Variant
+methodInvocation_VariantSuper :: Typed.TypedTerm Syntax.MethodInvocation_Variant
+methodInvocation_VariantSuper =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "super"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the type variant of hydra.java.syntax.MethodInvocation_Variant
+methodInvocation_VariantType :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.MethodInvocation_Variant
+methodInvocation_VariantType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the typeSuper variant of hydra.java.syntax.MethodInvocation_Variant
+methodInvocation_VariantTypeSuper :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.MethodInvocation_Variant
+methodInvocation_VariantTypeSuper x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodInvocation_Variant"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typeSuper"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the abstract variant of hydra.java.syntax.MethodModifier
+methodModifierAbstract :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierAbstract =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "abstract"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.MethodModifier
+methodModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.MethodModifier
+methodModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the final variant of hydra.java.syntax.MethodModifier
+methodModifierFinal :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierFinal =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "final"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the native variant of hydra.java.syntax.MethodModifier
+methodModifierNative :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierNative =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "native"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the private variant of hydra.java.syntax.MethodModifier
+methodModifierPrivate :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierPrivate =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "private"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the protected variant of hydra.java.syntax.MethodModifier
+methodModifierProtected :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierProtected =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "protected"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the public variant of hydra.java.syntax.MethodModifier
+methodModifierPublic :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierPublic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "public"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the static variant of hydra.java.syntax.MethodModifier
+methodModifierStatic :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierStatic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "static"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the strictfp variant of hydra.java.syntax.MethodModifier
+methodModifierStrictfp :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierStrictfp =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "strictfp"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the synchronized variant of hydra.java.syntax.MethodModifier
+methodModifierSynchronized :: Typed.TypedTerm Syntax.MethodModifier
+methodModifierSynchronized =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "synchronized"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.java.syntax.MethodName wrapper
+methodName :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodName
+methodName x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.MethodName"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the array variant of hydra.java.syntax.MethodReference
+methodReferenceArray :: Typed.TypedTerm Syntax.MethodReference_Array -> Typed.TypedTerm Syntax.MethodReference
+methodReferenceArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodReference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "array"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the expression variant of hydra.java.syntax.MethodReference
+methodReferenceExpression :: Typed.TypedTerm Syntax.MethodReference_Expression -> Typed.TypedTerm Syntax.MethodReference
+methodReferenceExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodReference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the new variant of hydra.java.syntax.MethodReference
+methodReferenceNew :: Typed.TypedTerm Syntax.MethodReference_New -> Typed.TypedTerm Syntax.MethodReference
+methodReferenceNew x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodReference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "new"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primary variant of hydra.java.syntax.MethodReference
+methodReferencePrimary :: Typed.TypedTerm Syntax.MethodReference_Primary -> Typed.TypedTerm Syntax.MethodReference
+methodReferencePrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodReference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the referenceType variant of hydra.java.syntax.MethodReference
+methodReferenceReferenceType :: Typed.TypedTerm Syntax.MethodReference_ReferenceType -> Typed.TypedTerm Syntax.MethodReference
+methodReferenceReferenceType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodReference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "referenceType"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the super variant of hydra.java.syntax.MethodReference
+methodReferenceSuper :: Typed.TypedTerm Syntax.MethodReference_Super -> Typed.TypedTerm Syntax.MethodReference
+methodReferenceSuper x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MethodReference"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "super"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.MethodReference_Array wrapper
+methodReference_Array :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.MethodReference_Array
+methodReference_Array x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.MethodReference_Array"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.MethodReference_Expression
+methodReference_Expression :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodReference_Expression
+methodReference_Expression name typeArguments identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.MethodReference_Expression
+methodReference_ExpressionIdentifier :: Typed.TypedTerm Syntax.MethodReference_Expression -> Typed.TypedTerm Syntax.Identifier
+methodReference_ExpressionIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.java.syntax.MethodReference_Expression
+methodReference_ExpressionName :: Typed.TypedTerm Syntax.MethodReference_Expression -> Typed.TypedTerm Syntax.ExpressionName
+methodReference_ExpressionName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.MethodReference_Expression
+methodReference_ExpressionTypeArguments :: Typed.TypedTerm Syntax.MethodReference_Expression -> Typed.TypedTerm [Syntax.TypeArgument]
+methodReference_ExpressionTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.MethodReference_Expression
+methodReference_ExpressionWithIdentifier :: Typed.TypedTerm Syntax.MethodReference_Expression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodReference_Expression
+methodReference_ExpressionWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+      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.java.syntax.MethodReference_Expression"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.java.syntax.MethodReference_Expression
+methodReference_ExpressionWithName :: Typed.TypedTerm Syntax.MethodReference_Expression -> Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.MethodReference_Expression
+methodReference_ExpressionWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.MethodReference_Expression
+methodReference_ExpressionWithTypeArguments :: Typed.TypedTerm Syntax.MethodReference_Expression -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.MethodReference_Expression
+methodReference_ExpressionWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+      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.java.syntax.MethodReference_Expression"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Expression"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.MethodReference_New
+methodReference_New :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.MethodReference_New
+methodReference_New classType typeArguments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_New"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "classType"),
+          Core.fieldTerm = (Typed.unTypedTerm classType)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))
+
+-- | DSL accessor for the classType field of hydra.java.syntax.MethodReference_New
+methodReference_NewClassType :: Typed.TypedTerm Syntax.MethodReference_New -> Typed.TypedTerm Syntax.ClassType
+methodReference_NewClassType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_New"),
+        Core.projectionFieldName = (Core.Name "classType")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.MethodReference_New
+methodReference_NewTypeArguments :: Typed.TypedTerm Syntax.MethodReference_New -> Typed.TypedTerm [Syntax.TypeArgument]
+methodReference_NewTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_New"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the classType field of hydra.java.syntax.MethodReference_New
+methodReference_NewWithClassType :: Typed.TypedTerm Syntax.MethodReference_New -> Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.MethodReference_New
+methodReference_NewWithClassType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_New"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "classType"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_New"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.MethodReference_New
+methodReference_NewWithTypeArguments :: Typed.TypedTerm Syntax.MethodReference_New -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.MethodReference_New
+methodReference_NewWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_New"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "classType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_New"),
+              Core.projectionFieldName = (Core.Name "classType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.MethodReference_Primary
+methodReference_Primary :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodReference_Primary
+methodReference_Primary primary typeArguments identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "primary"),
+          Core.fieldTerm = (Typed.unTypedTerm primary)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.MethodReference_Primary
+methodReference_PrimaryIdentifier :: Typed.TypedTerm Syntax.MethodReference_Primary -> Typed.TypedTerm Syntax.Identifier
+methodReference_PrimaryIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the primary field of hydra.java.syntax.MethodReference_Primary
+methodReference_PrimaryPrimary :: Typed.TypedTerm Syntax.MethodReference_Primary -> Typed.TypedTerm Syntax.Primary
+methodReference_PrimaryPrimary x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+        Core.projectionFieldName = (Core.Name "primary")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.MethodReference_Primary
+methodReference_PrimaryTypeArguments :: Typed.TypedTerm Syntax.MethodReference_Primary -> Typed.TypedTerm [Syntax.TypeArgument]
+methodReference_PrimaryTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.MethodReference_Primary
+methodReference_PrimaryWithIdentifier :: Typed.TypedTerm Syntax.MethodReference_Primary -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodReference_Primary
+methodReference_PrimaryWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "primary"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+              Core.projectionFieldName = (Core.Name "primary")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the primary field of hydra.java.syntax.MethodReference_Primary
+methodReference_PrimaryWithPrimary :: Typed.TypedTerm Syntax.MethodReference_Primary -> Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.MethodReference_Primary
+methodReference_PrimaryWithPrimary original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "primary"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.MethodReference_Primary
+methodReference_PrimaryWithTypeArguments :: Typed.TypedTerm Syntax.MethodReference_Primary -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.MethodReference_Primary
+methodReference_PrimaryWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "primary"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+              Core.projectionFieldName = (Core.Name "primary")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Primary"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.MethodReference_ReferenceType
+methodReference_ReferenceType :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodReference_ReferenceType
+methodReference_ReferenceType referenceType typeArguments identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "referenceType"),
+          Core.fieldTerm = (Typed.unTypedTerm referenceType)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeIdentifier :: Typed.TypedTerm Syntax.MethodReference_ReferenceType -> Typed.TypedTerm Syntax.Identifier
+methodReference_ReferenceTypeIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the referenceType field of hydra.java.syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeReferenceType :: Typed.TypedTerm Syntax.MethodReference_ReferenceType -> Typed.TypedTerm Syntax.ReferenceType
+methodReference_ReferenceTypeReferenceType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+        Core.projectionFieldName = (Core.Name "referenceType")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeTypeArguments :: Typed.TypedTerm Syntax.MethodReference_ReferenceType -> Typed.TypedTerm [Syntax.TypeArgument]
+methodReference_ReferenceTypeTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeWithIdentifier :: Typed.TypedTerm Syntax.MethodReference_ReferenceType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "referenceType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+              Core.projectionFieldName = (Core.Name "referenceType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the referenceType field of hydra.java.syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeWithReferenceType :: Typed.TypedTerm Syntax.MethodReference_ReferenceType -> Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeWithReferenceType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "referenceType"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeWithTypeArguments :: Typed.TypedTerm Syntax.MethodReference_ReferenceType -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.MethodReference_ReferenceType
+methodReference_ReferenceTypeWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "referenceType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+              Core.projectionFieldName = (Core.Name "referenceType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_ReferenceType"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.MethodReference_Super
+methodReference_Super :: Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.MethodReference_Super
+methodReference_Super typeArguments identifier super =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "super"),
+          Core.fieldTerm = (Typed.unTypedTerm super)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.MethodReference_Super
+methodReference_SuperIdentifier :: Typed.TypedTerm Syntax.MethodReference_Super -> Typed.TypedTerm Syntax.Identifier
+methodReference_SuperIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the super field of hydra.java.syntax.MethodReference_Super
+methodReference_SuperSuper :: Typed.TypedTerm Syntax.MethodReference_Super -> Typed.TypedTerm Bool
+methodReference_SuperSuper x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+        Core.projectionFieldName = (Core.Name "super")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.MethodReference_Super
+methodReference_SuperTypeArguments :: Typed.TypedTerm Syntax.MethodReference_Super -> Typed.TypedTerm [Syntax.TypeArgument]
+methodReference_SuperTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.MethodReference_Super
+methodReference_SuperWithIdentifier :: Typed.TypedTerm Syntax.MethodReference_Super -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MethodReference_Super
+methodReference_SuperWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "super"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+              Core.projectionFieldName = (Core.Name "super")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the super field of hydra.java.syntax.MethodReference_Super
+methodReference_SuperWithSuper :: Typed.TypedTerm Syntax.MethodReference_Super -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.MethodReference_Super
+methodReference_SuperWithSuper original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "super"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.MethodReference_Super
+methodReference_SuperWithTypeArguments :: Typed.TypedTerm Syntax.MethodReference_Super -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.MethodReference_Super
+methodReference_SuperWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "super"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.MethodReference_Super"),
+              Core.projectionFieldName = (Core.Name "super")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.ModularCompilationUnit
+modularCompilationUnit :: Typed.TypedTerm [Syntax.ImportDeclaration] -> Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm Syntax.ModularCompilationUnit
+modularCompilationUnit imports module_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModularCompilationUnit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Typed.unTypedTerm imports)},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Typed.unTypedTerm module_)}]}))
+
+-- | DSL accessor for the imports field of hydra.java.syntax.ModularCompilationUnit
+modularCompilationUnitImports :: Typed.TypedTerm Syntax.ModularCompilationUnit -> Typed.TypedTerm [Syntax.ImportDeclaration]
+modularCompilationUnitImports x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModularCompilationUnit"),
+        Core.projectionFieldName = (Core.Name "imports")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the module field of hydra.java.syntax.ModularCompilationUnit
+modularCompilationUnitModule :: Typed.TypedTerm Syntax.ModularCompilationUnit -> Typed.TypedTerm Syntax.ModuleDeclaration
+modularCompilationUnitModule x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModularCompilationUnit"),
+        Core.projectionFieldName = (Core.Name "module")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the imports field of hydra.java.syntax.ModularCompilationUnit
+modularCompilationUnitWithImports :: Typed.TypedTerm Syntax.ModularCompilationUnit -> Typed.TypedTerm [Syntax.ImportDeclaration] -> Typed.TypedTerm Syntax.ModularCompilationUnit
+modularCompilationUnitWithImports original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModularCompilationUnit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModularCompilationUnit"),
+              Core.projectionFieldName = (Core.Name "module")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the module field of hydra.java.syntax.ModularCompilationUnit
+modularCompilationUnitWithModule :: Typed.TypedTerm Syntax.ModularCompilationUnit -> Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm Syntax.ModularCompilationUnit
+modularCompilationUnitWithModule original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModularCompilationUnit"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "imports"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModularCompilationUnit"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.ModuleDeclaration
+moduleDeclaration :: Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm [Syntax.ModuleDirective] -> Typed.TypedTerm Syntax.ModuleDeclaration
+moduleDeclaration annotations open identifiers directives =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "open"),
+          Core.fieldTerm = (Typed.unTypedTerm open)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm identifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "directives"),
+          Core.fieldTerm = (Typed.unTypedTerm directives)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.ModuleDeclaration
+moduleDeclarationAnnotations :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm [Syntax.Annotation]
+moduleDeclarationAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the directives field of hydra.java.syntax.ModuleDeclaration
+moduleDeclarationDirectives :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm [Syntax.ModuleDirective]
+moduleDeclarationDirectives x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+        Core.projectionFieldName = (Core.Name "directives")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifiers field of hydra.java.syntax.ModuleDeclaration
+moduleDeclarationIdentifiers :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm [Syntax.Identifier]
+moduleDeclarationIdentifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the open field of hydra.java.syntax.ModuleDeclaration
+moduleDeclarationOpen :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm Bool
+moduleDeclarationOpen x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+        Core.projectionFieldName = (Core.Name "open")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.ModuleDeclaration
+moduleDeclarationWithAnnotations :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.ModuleDeclaration
+moduleDeclarationWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "open"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "open")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "directives"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "directives")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the directives field of hydra.java.syntax.ModuleDeclaration
+moduleDeclarationWithDirectives :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm [Syntax.ModuleDirective] -> Typed.TypedTerm Syntax.ModuleDeclaration
+moduleDeclarationWithDirectives original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "open"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "open")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "directives"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifiers field of hydra.java.syntax.ModuleDeclaration
+moduleDeclarationWithIdentifiers :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.ModuleDeclaration
+moduleDeclarationWithIdentifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "open"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "open")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "directives"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "directives")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the open field of hydra.java.syntax.ModuleDeclaration
+moduleDeclarationWithOpen :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ModuleDeclaration
+moduleDeclarationWithOpen original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "open"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "directives"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDeclaration"),
+              Core.projectionFieldName = (Core.Name "directives")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the exports variant of hydra.java.syntax.ModuleDirective
+moduleDirectiveExports :: Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens -> Typed.TypedTerm Syntax.ModuleDirective
+moduleDirectiveExports x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "exports"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the opens variant of hydra.java.syntax.ModuleDirective
+moduleDirectiveOpens :: Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens -> Typed.TypedTerm Syntax.ModuleDirective
+moduleDirectiveOpens x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "opens"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the provides variant of hydra.java.syntax.ModuleDirective
+moduleDirectiveProvides :: Typed.TypedTerm Syntax.ModuleDirective_Provides -> Typed.TypedTerm Syntax.ModuleDirective
+moduleDirectiveProvides x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "provides"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the requires variant of hydra.java.syntax.ModuleDirective
+moduleDirectiveRequires :: Typed.TypedTerm Syntax.ModuleDirective_Requires -> Typed.TypedTerm Syntax.ModuleDirective
+moduleDirectiveRequires x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "requires"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the uses variant of hydra.java.syntax.ModuleDirective
+moduleDirectiveUses :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.ModuleDirective
+moduleDirectiveUses x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "uses"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ModuleDirective_ExportsOrOpens
+moduleDirective_ExportsOrOpens :: Typed.TypedTerm Syntax.PackageName -> Typed.TypedTerm [Syntax.ModuleName] -> Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens
+moduleDirective_ExportsOrOpens package modules =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_ExportsOrOpens"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Typed.unTypedTerm package)},
+        Core.Field {
+          Core.fieldName = (Core.Name "modules"),
+          Core.fieldTerm = (Typed.unTypedTerm modules)}]}))
+
+-- | DSL accessor for the modules field of hydra.java.syntax.ModuleDirective_ExportsOrOpens
+moduleDirective_ExportsOrOpensModules :: Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens -> Typed.TypedTerm [Syntax.ModuleName]
+moduleDirective_ExportsOrOpensModules x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_ExportsOrOpens"),
+        Core.projectionFieldName = (Core.Name "modules")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the package field of hydra.java.syntax.ModuleDirective_ExportsOrOpens
+moduleDirective_ExportsOrOpensPackage :: Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens -> Typed.TypedTerm Syntax.PackageName
+moduleDirective_ExportsOrOpensPackage x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_ExportsOrOpens"),
+        Core.projectionFieldName = (Core.Name "package")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the modules field of hydra.java.syntax.ModuleDirective_ExportsOrOpens
+moduleDirective_ExportsOrOpensWithModules :: Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens -> Typed.TypedTerm [Syntax.ModuleName] -> Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens
+moduleDirective_ExportsOrOpensWithModules original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_ExportsOrOpens"),
+      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.java.syntax.ModuleDirective_ExportsOrOpens"),
+              Core.projectionFieldName = (Core.Name "package")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "modules"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the package field of hydra.java.syntax.ModuleDirective_ExportsOrOpens
+moduleDirective_ExportsOrOpensWithPackage :: Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens -> Typed.TypedTerm Syntax.PackageName -> Typed.TypedTerm Syntax.ModuleDirective_ExportsOrOpens
+moduleDirective_ExportsOrOpensWithPackage original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_ExportsOrOpens"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "package"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "modules"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_ExportsOrOpens"),
+              Core.projectionFieldName = (Core.Name "modules")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.ModuleDirective_Provides
+moduleDirective_Provides :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm [Syntax.TypeName] -> Typed.TypedTerm Syntax.ModuleDirective_Provides
+moduleDirective_Provides to with =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Provides"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "to"),
+          Core.fieldTerm = (Typed.unTypedTerm to)},
+        Core.Field {
+          Core.fieldName = (Core.Name "with"),
+          Core.fieldTerm = (Typed.unTypedTerm with)}]}))
+
+-- | DSL accessor for the to field of hydra.java.syntax.ModuleDirective_Provides
+moduleDirective_ProvidesTo :: Typed.TypedTerm Syntax.ModuleDirective_Provides -> Typed.TypedTerm Syntax.TypeName
+moduleDirective_ProvidesTo x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Provides"),
+        Core.projectionFieldName = (Core.Name "to")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the with field of hydra.java.syntax.ModuleDirective_Provides
+moduleDirective_ProvidesWith :: Typed.TypedTerm Syntax.ModuleDirective_Provides -> Typed.TypedTerm [Syntax.TypeName]
+moduleDirective_ProvidesWith x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Provides"),
+        Core.projectionFieldName = (Core.Name "with")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the to field of hydra.java.syntax.ModuleDirective_Provides
+moduleDirective_ProvidesWithTo :: Typed.TypedTerm Syntax.ModuleDirective_Provides -> Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.ModuleDirective_Provides
+moduleDirective_ProvidesWithTo original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Provides"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "to"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "with"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Provides"),
+              Core.projectionFieldName = (Core.Name "with")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the with field of hydra.java.syntax.ModuleDirective_Provides
+moduleDirective_ProvidesWithWith :: Typed.TypedTerm Syntax.ModuleDirective_Provides -> Typed.TypedTerm [Syntax.TypeName] -> Typed.TypedTerm Syntax.ModuleDirective_Provides
+moduleDirective_ProvidesWithWith original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Provides"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "to"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Provides"),
+              Core.projectionFieldName = (Core.Name "to")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "with"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.ModuleDirective_Requires
+moduleDirective_Requires :: Typed.TypedTerm [Syntax.RequiresModifier] -> Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.ModuleDirective_Requires
+moduleDirective_Requires modifiers module_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Requires"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Typed.unTypedTerm module_)}]}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.ModuleDirective_Requires
+moduleDirective_RequiresModifiers :: Typed.TypedTerm Syntax.ModuleDirective_Requires -> Typed.TypedTerm [Syntax.RequiresModifier]
+moduleDirective_RequiresModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Requires"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the module field of hydra.java.syntax.ModuleDirective_Requires
+moduleDirective_RequiresModule :: Typed.TypedTerm Syntax.ModuleDirective_Requires -> Typed.TypedTerm Syntax.ModuleName
+moduleDirective_RequiresModule x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Requires"),
+        Core.projectionFieldName = (Core.Name "module")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.ModuleDirective_Requires
+moduleDirective_RequiresWithModifiers :: Typed.TypedTerm Syntax.ModuleDirective_Requires -> Typed.TypedTerm [Syntax.RequiresModifier] -> Typed.TypedTerm Syntax.ModuleDirective_Requires
+moduleDirective_RequiresWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Requires"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Requires"),
+              Core.projectionFieldName = (Core.Name "module")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the module field of hydra.java.syntax.ModuleDirective_Requires
+moduleDirective_RequiresWithModule :: Typed.TypedTerm Syntax.ModuleDirective_Requires -> Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.ModuleDirective_Requires
+moduleDirective_RequiresWithModule original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Requires"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleDirective_Requires"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "module"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.ModuleName
+moduleName :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.ModuleName) -> Typed.TypedTerm Syntax.ModuleName
+moduleName identifier name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.ModuleName
+moduleNameIdentifier :: Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.Identifier
+moduleNameIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleName"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.java.syntax.ModuleName
+moduleNameName :: Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm (Maybe Syntax.ModuleName)
+moduleNameName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleName"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.ModuleName
+moduleNameWithIdentifier :: Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ModuleName
+moduleNameWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          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.java.syntax.ModuleName"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.java.syntax.ModuleName
+moduleNameWithName :: Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm (Maybe Syntax.ModuleName) -> Typed.TypedTerm Syntax.ModuleName
+moduleNameWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ModuleName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ModuleName"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the divide variant of hydra.java.syntax.MultiplicativeExpression
+multiplicativeExpressionDivide :: Typed.TypedTerm Syntax.MultiplicativeExpression_Binary -> Typed.TypedTerm Syntax.MultiplicativeExpression
+multiplicativeExpressionDivide x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "divide"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the mod variant of hydra.java.syntax.MultiplicativeExpression
+multiplicativeExpressionMod :: Typed.TypedTerm Syntax.MultiplicativeExpression_Binary -> Typed.TypedTerm Syntax.MultiplicativeExpression
+multiplicativeExpressionMod x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "mod"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the times variant of hydra.java.syntax.MultiplicativeExpression
+multiplicativeExpressionTimes :: Typed.TypedTerm Syntax.MultiplicativeExpression_Binary -> Typed.TypedTerm Syntax.MultiplicativeExpression
+multiplicativeExpressionTimes x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "times"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the unary variant of hydra.java.syntax.MultiplicativeExpression
+multiplicativeExpressionUnary :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression
+multiplicativeExpressionUnary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.MultiplicativeExpression_Binary
+multiplicativeExpression_Binary :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression_Binary
+multiplicativeExpression_Binary lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression_Binary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.MultiplicativeExpression_Binary
+multiplicativeExpression_BinaryLhs :: Typed.TypedTerm Syntax.MultiplicativeExpression_Binary -> Typed.TypedTerm Syntax.MultiplicativeExpression
+multiplicativeExpression_BinaryLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression_Binary"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.MultiplicativeExpression_Binary
+multiplicativeExpression_BinaryRhs :: Typed.TypedTerm Syntax.MultiplicativeExpression_Binary -> Typed.TypedTerm Syntax.UnaryExpression
+multiplicativeExpression_BinaryRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression_Binary"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.MultiplicativeExpression_Binary
+multiplicativeExpression_BinaryWithLhs :: Typed.TypedTerm Syntax.MultiplicativeExpression_Binary -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression_Binary
+multiplicativeExpression_BinaryWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression_Binary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.MultiplicativeExpression_Binary"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.MultiplicativeExpression_Binary
+multiplicativeExpression_BinaryWithRhs :: Typed.TypedTerm Syntax.MultiplicativeExpression_Binary -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression_Binary
+multiplicativeExpression_BinaryWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.MultiplicativeExpression_Binary"),
+      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.java.syntax.MultiplicativeExpression_Binary"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.NormalAnnotation
+normalAnnotation :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm [Syntax.ElementValuePair] -> Typed.TypedTerm Syntax.NormalAnnotation
+normalAnnotation typeName pairs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalAnnotation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeName"),
+          Core.fieldTerm = (Typed.unTypedTerm typeName)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pairs"),
+          Core.fieldTerm = (Typed.unTypedTerm pairs)}]}))
+
+-- | DSL accessor for the pairs field of hydra.java.syntax.NormalAnnotation
+normalAnnotationPairs :: Typed.TypedTerm Syntax.NormalAnnotation -> Typed.TypedTerm [Syntax.ElementValuePair]
+normalAnnotationPairs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalAnnotation"),
+        Core.projectionFieldName = (Core.Name "pairs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeName field of hydra.java.syntax.NormalAnnotation
+normalAnnotationTypeName :: Typed.TypedTerm Syntax.NormalAnnotation -> Typed.TypedTerm Syntax.TypeName
+normalAnnotationTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalAnnotation"),
+        Core.projectionFieldName = (Core.Name "typeName")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the pairs field of hydra.java.syntax.NormalAnnotation
+normalAnnotationWithPairs :: Typed.TypedTerm Syntax.NormalAnnotation -> Typed.TypedTerm [Syntax.ElementValuePair] -> Typed.TypedTerm Syntax.NormalAnnotation
+normalAnnotationWithPairs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalAnnotation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeName"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalAnnotation"),
+              Core.projectionFieldName = (Core.Name "typeName")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pairs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the typeName field of hydra.java.syntax.NormalAnnotation
+normalAnnotationWithTypeName :: Typed.TypedTerm Syntax.NormalAnnotation -> Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.NormalAnnotation
+normalAnnotationWithTypeName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalAnnotation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeName"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pairs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalAnnotation"),
+              Core.projectionFieldName = (Core.Name "pairs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.NormalClassDeclaration
+normalClassDeclaration :: Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm (Maybe Syntax.ClassType) -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm [Syntax.TypeName] -> Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm Syntax.NormalClassDeclaration
+normalClassDeclaration modifiers identifier parameters extends implements permits body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm parameters)},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Typed.unTypedTerm extends)},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Typed.unTypedTerm implements)},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Typed.unTypedTerm permits)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationBody :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm Syntax.ClassBody
+normalClassDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the extends field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationExtends :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassType)
+normalClassDeclarationExtends x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+        Core.projectionFieldName = (Core.Name "extends")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationIdentifier :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier
+normalClassDeclarationIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the implements field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationImplements :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm [Syntax.InterfaceType]
+normalClassDeclarationImplements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+        Core.projectionFieldName = (Core.Name "implements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationModifiers :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm [Syntax.ClassModifier]
+normalClassDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parameters field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationParameters :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm [Syntax.TypeParameter]
+normalClassDeclarationParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+        Core.projectionFieldName = (Core.Name "parameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the permits field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationPermits :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm [Syntax.TypeName]
+normalClassDeclarationPermits x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+        Core.projectionFieldName = (Core.Name "permits")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationWithBody :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm Syntax.NormalClassDeclaration
+normalClassDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the extends field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationWithExtends :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassType) -> Typed.TypedTerm Syntax.NormalClassDeclaration
+normalClassDeclarationWithExtends original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationWithIdentifier :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.NormalClassDeclaration
+normalClassDeclarationWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the implements field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationWithImplements :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.NormalClassDeclaration
+normalClassDeclarationWithImplements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationWithModifiers :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Syntax.NormalClassDeclaration
+normalClassDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the parameters field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationWithParameters :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.NormalClassDeclaration
+normalClassDeclarationWithParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the permits field of hydra.java.syntax.NormalClassDeclaration
+normalClassDeclarationWithPermits :: Typed.TypedTerm Syntax.NormalClassDeclaration -> Typed.TypedTerm [Syntax.TypeName] -> Typed.TypedTerm Syntax.NormalClassDeclaration
+normalClassDeclarationWithPermits original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          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.java.syntax.NormalClassDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclaration :: Typed.TypedTerm [Syntax.InterfaceModifier] -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm [Syntax.TypeName] -> Typed.TypedTerm Syntax.InterfaceBody -> Typed.TypedTerm Syntax.NormalInterfaceDeclaration
+normalInterfaceDeclaration modifiers identifier parameters extends permits body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm parameters)},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Typed.unTypedTerm extends)},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Typed.unTypedTerm permits)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationBody :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm Syntax.InterfaceBody
+normalInterfaceDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the extends field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationExtends :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceType]
+normalInterfaceDeclarationExtends x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "extends")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationIdentifier :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier
+normalInterfaceDeclarationIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationModifiers :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceModifier]
+normalInterfaceDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parameters field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationParameters :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm [Syntax.TypeParameter]
+normalInterfaceDeclarationParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "parameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the permits field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationPermits :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm [Syntax.TypeName]
+normalInterfaceDeclarationPermits x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+        Core.projectionFieldName = (Core.Name "permits")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithBody :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm Syntax.InterfaceBody -> Typed.TypedTerm Syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the extends field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithExtends :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithExtends original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithIdentifier :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithModifiers :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceModifier] -> Typed.TypedTerm Syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the parameters field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithParameters :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "permits")})),
+            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.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the permits field of hydra.java.syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithPermits :: Typed.TypedTerm Syntax.NormalInterfaceDeclaration -> Typed.TypedTerm [Syntax.TypeName] -> Typed.TypedTerm Syntax.NormalInterfaceDeclaration
+normalInterfaceDeclarationWithPermits original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extends"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "extends")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "permits"),
+          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.java.syntax.NormalInterfaceDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the array variant of hydra.java.syntax.NumericTypeArray
+numericTypeArrayArray :: Typed.TypedTerm Syntax.NumericTypeArray -> Typed.TypedTerm Syntax.NumericTypeArray
+numericTypeArrayArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.NumericTypeArray"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "array"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.NumericTypeArray
+numericTypeArraySimple :: Typed.TypedTerm Syntax.NumericType -> Typed.TypedTerm Syntax.NumericTypeArray
+numericTypeArraySimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.NumericTypeArray"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the floatingPoint variant of hydra.java.syntax.NumericType
+numericTypeFloatingPoint :: Typed.TypedTerm Syntax.FloatingPointType -> Typed.TypedTerm Syntax.NumericType
+numericTypeFloatingPoint x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.NumericType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "floatingPoint"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the integral variant of hydra.java.syntax.NumericType
+numericTypeIntegral :: Typed.TypedTerm Syntax.IntegralType -> Typed.TypedTerm Syntax.NumericType
+numericTypeIntegral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.NumericType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "integral"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnit :: Typed.TypedTerm (Maybe Syntax.PackageDeclaration) -> Typed.TypedTerm [Syntax.ImportDeclaration] -> Typed.TypedTerm [Syntax.TopLevelClassOrInterfaceDeclarationWithComments] -> Typed.TypedTerm Syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnit package imports types =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+      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 "types"),
+          Core.fieldTerm = (Typed.unTypedTerm types)}]}))
+
+-- | DSL accessor for the imports field of hydra.java.syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitImports :: Typed.TypedTerm Syntax.OrdinaryCompilationUnit -> Typed.TypedTerm [Syntax.ImportDeclaration]
+ordinaryCompilationUnitImports x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+        Core.projectionFieldName = (Core.Name "imports")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the package field of hydra.java.syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitPackage :: Typed.TypedTerm Syntax.OrdinaryCompilationUnit -> Typed.TypedTerm (Maybe Syntax.PackageDeclaration)
+ordinaryCompilationUnitPackage x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+        Core.projectionFieldName = (Core.Name "package")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the types field of hydra.java.syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitTypes :: Typed.TypedTerm Syntax.OrdinaryCompilationUnit -> Typed.TypedTerm [Syntax.TopLevelClassOrInterfaceDeclarationWithComments]
+ordinaryCompilationUnitTypes x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+        Core.projectionFieldName = (Core.Name "types")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the imports field of hydra.java.syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitWithImports :: Typed.TypedTerm Syntax.OrdinaryCompilationUnit -> Typed.TypedTerm [Syntax.ImportDeclaration] -> Typed.TypedTerm Syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitWithImports original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+      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.java.syntax.OrdinaryCompilationUnit"),
+              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 "types"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+              Core.projectionFieldName = (Core.Name "types")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the package field of hydra.java.syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitWithPackage :: Typed.TypedTerm Syntax.OrdinaryCompilationUnit -> Typed.TypedTerm (Maybe Syntax.PackageDeclaration) -> Typed.TypedTerm Syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitWithPackage original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+      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.java.syntax.OrdinaryCompilationUnit"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "types"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+              Core.projectionFieldName = (Core.Name "types")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the types field of hydra.java.syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitWithTypes :: Typed.TypedTerm Syntax.OrdinaryCompilationUnit -> Typed.TypedTerm [Syntax.TopLevelClassOrInterfaceDeclarationWithComments] -> Typed.TypedTerm Syntax.OrdinaryCompilationUnit
+ordinaryCompilationUnitWithTypes original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"),
+      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.java.syntax.OrdinaryCompilationUnit"),
+              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.java.syntax.OrdinaryCompilationUnit"),
+              Core.projectionFieldName = (Core.Name "imports")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "types"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.PackageDeclaration
+packageDeclaration :: Typed.TypedTerm [Syntax.PackageModifier] -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.PackageDeclaration
+packageDeclaration modifiers identifiers =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.PackageDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm identifiers)}]}))
+
+-- | DSL accessor for the identifiers field of hydra.java.syntax.PackageDeclaration
+packageDeclarationIdentifiers :: Typed.TypedTerm Syntax.PackageDeclaration -> Typed.TypedTerm [Syntax.Identifier]
+packageDeclarationIdentifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.PackageDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.PackageDeclaration
+packageDeclarationModifiers :: Typed.TypedTerm Syntax.PackageDeclaration -> Typed.TypedTerm [Syntax.PackageModifier]
+packageDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.PackageDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifiers field of hydra.java.syntax.PackageDeclaration
+packageDeclarationWithIdentifiers :: Typed.TypedTerm Syntax.PackageDeclaration -> Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.PackageDeclaration
+packageDeclarationWithIdentifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.PackageDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.PackageDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.PackageDeclaration
+packageDeclarationWithModifiers :: Typed.TypedTerm Syntax.PackageDeclaration -> Typed.TypedTerm [Syntax.PackageModifier] -> Typed.TypedTerm Syntax.PackageDeclaration
+packageDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.PackageDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.PackageDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.PackageModifier wrapper
+packageModifier :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.PackageModifier
+packageModifier x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.PackageModifier"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.PackageName wrapper
+packageName :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.PackageName
+packageName x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.PackageName"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.PackageOrTypeName wrapper
+packageOrTypeName :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.PackageOrTypeName
+packageOrTypeName x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.PackageOrTypeName"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the record variant of hydra.java.syntax.Pattern
+patternRecord :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm Syntax.Pattern
+patternRecord x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Pattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "record"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.java.syntax.Pattern
+patternType :: Typed.TypedTerm Syntax.TypePattern -> Typed.TypedTerm Syntax.Pattern
+patternType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Pattern"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.PostDecrementExpression wrapper
+postDecrementExpression :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.PostDecrementExpression
+postDecrementExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.PostDecrementExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.PostIncrementExpression wrapper
+postIncrementExpression :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.PostIncrementExpression
+postIncrementExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.PostIncrementExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the name variant of hydra.java.syntax.PostfixExpression
+postfixExpressionName :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.PostfixExpression
+postfixExpressionName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PostfixExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the postDecrement variant of hydra.java.syntax.PostfixExpression
+postfixExpressionPostDecrement :: Typed.TypedTerm Syntax.PostDecrementExpression -> Typed.TypedTerm Syntax.PostfixExpression
+postfixExpressionPostDecrement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PostfixExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "postDecrement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the postIncrement variant of hydra.java.syntax.PostfixExpression
+postfixExpressionPostIncrement :: Typed.TypedTerm Syntax.PostIncrementExpression -> Typed.TypedTerm Syntax.PostfixExpression
+postfixExpressionPostIncrement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PostfixExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "postIncrement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the primary variant of hydra.java.syntax.PostfixExpression
+postfixExpressionPrimary :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.PostfixExpression
+postfixExpressionPrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PostfixExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.PreDecrementExpression wrapper
+preDecrementExpression :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.PreDecrementExpression
+preDecrementExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.PreDecrementExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.PreIncrementExpression wrapper
+preIncrementExpression :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.PreIncrementExpression
+preIncrementExpression x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.PreIncrementExpression"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the arrayCreation variant of hydra.java.syntax.Primary
+primaryArrayCreation :: Typed.TypedTerm Syntax.ArrayCreationExpression -> Typed.TypedTerm Syntax.Primary
+primaryArrayCreation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Primary"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "arrayCreation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the noNewArray variant of hydra.java.syntax.Primary
+primaryNoNewArray :: Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression -> Typed.TypedTerm Syntax.Primary
+primaryNoNewArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Primary"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "noNewArray"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the arrayAccess variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionArrayAccess :: Typed.TypedTerm Syntax.ArrayAccess -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionArrayAccess x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "arrayAccess"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the classInstance variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionClassInstance :: Typed.TypedTerm Syntax.ClassInstanceCreationExpression -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionClassInstance x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classInstance"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the classLiteral variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionClassLiteral :: Typed.TypedTerm Syntax.ClassLiteral -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionClassLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classLiteral"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the dotThis variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionDotThis :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionDotThis x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "dotThis"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the fieldAccess variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionFieldAccess :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionFieldAccess x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "fieldAccess"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the literal variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionLiteral x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "literal"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the methodInvocation variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionMethodInvocation :: Typed.TypedTerm Syntax.MethodInvocation -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionMethodInvocation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "methodInvocation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the methodReference variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionMethodReference :: Typed.TypedTerm Syntax.MethodReference -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionMethodReference x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "methodReference"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the parens variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionParens :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionParens x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "parens"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the this variant of hydra.java.syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionThis :: Typed.TypedTerm Syntax.PrimaryNoNewArrayExpression
+primaryNoNewArrayExpressionThis =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "this"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the boolean variant of hydra.java.syntax.PrimitiveType
+primitiveTypeBoolean :: Typed.TypedTerm Syntax.PrimitiveType
+primitiveTypeBoolean =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimitiveType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "boolean"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the numeric variant of hydra.java.syntax.PrimitiveType
+primitiveTypeNumeric :: Typed.TypedTerm Syntax.NumericType -> Typed.TypedTerm Syntax.PrimitiveType
+primitiveTypeNumeric x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.PrimitiveType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "numeric"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.PrimitiveTypeWithAnnotations
+primitiveTypeWithAnnotations :: Typed.TypedTerm Syntax.PrimitiveType -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations
+primitiveTypeWithAnnotations type_ annotations =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.PrimitiveTypeWithAnnotations"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.PrimitiveTypeWithAnnotations
+primitiveTypeWithAnnotationsAnnotations :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm [Syntax.Annotation]
+primitiveTypeWithAnnotationsAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.PrimitiveTypeWithAnnotations"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.PrimitiveTypeWithAnnotations
+primitiveTypeWithAnnotationsType :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm Syntax.PrimitiveType
+primitiveTypeWithAnnotationsType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.PrimitiveTypeWithAnnotations"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.PrimitiveTypeWithAnnotations
+primitiveTypeWithAnnotationsWithAnnotations :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations
+primitiveTypeWithAnnotationsWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.PrimitiveTypeWithAnnotations"),
+      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.java.syntax.PrimitiveTypeWithAnnotations"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.PrimitiveTypeWithAnnotations
+primitiveTypeWithAnnotationsWithType :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm Syntax.PrimitiveType -> Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations
+primitiveTypeWithAnnotationsWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.PrimitiveTypeWithAnnotations"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.PrimitiveTypeWithAnnotations"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.ReceiverParameter
+receiverParameter :: Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ReceiverParameter
+receiverParameter annotations unannType identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "unannType"),
+          Core.fieldTerm = (Typed.unTypedTerm unannType)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.ReceiverParameter
+receiverParameterAnnotations :: Typed.TypedTerm Syntax.ReceiverParameter -> Typed.TypedTerm [Syntax.Annotation]
+receiverParameterAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.ReceiverParameter
+receiverParameterIdentifier :: Typed.TypedTerm Syntax.ReceiverParameter -> Typed.TypedTerm (Maybe Syntax.Identifier)
+receiverParameterIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the unannType field of hydra.java.syntax.ReceiverParameter
+receiverParameterUnannType :: Typed.TypedTerm Syntax.ReceiverParameter -> Typed.TypedTerm Syntax.UnannType
+receiverParameterUnannType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+        Core.projectionFieldName = (Core.Name "unannType")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.ReceiverParameter
+receiverParameterWithAnnotations :: Typed.TypedTerm Syntax.ReceiverParameter -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.ReceiverParameter
+receiverParameterWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "unannType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+              Core.projectionFieldName = (Core.Name "unannType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.ReceiverParameter
+receiverParameterWithIdentifier :: Typed.TypedTerm Syntax.ReceiverParameter -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ReceiverParameter
+receiverParameterWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "unannType"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+              Core.projectionFieldName = (Core.Name "unannType")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the unannType field of hydra.java.syntax.ReceiverParameter
+receiverParameterWithUnannType :: Typed.TypedTerm Syntax.ReceiverParameter -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.ReceiverParameter
+receiverParameterWithUnannType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "unannType"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.ReceiverParameter"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.RecordBody wrapper
+recordBody :: Typed.TypedTerm [Syntax.RecordBodyDeclaration] -> Typed.TypedTerm Syntax.RecordBody
+recordBody x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.RecordBody"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the classBody variant of hydra.java.syntax.RecordBodyDeclaration
+recordBodyDeclarationClassBody :: Typed.TypedTerm Syntax.ClassBodyDeclaration -> Typed.TypedTerm Syntax.RecordBodyDeclaration
+recordBodyDeclarationClassBody x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RecordBodyDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classBody"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the compactConstructor variant of hydra.java.syntax.RecordBodyDeclaration
+recordBodyDeclarationCompactConstructor :: Typed.TypedTerm Syntax.CompactConstructorDeclaration -> Typed.TypedTerm Syntax.RecordBodyDeclaration
+recordBodyDeclarationCompactConstructor x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RecordBodyDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "compactConstructor"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.RecordComponentModifier wrapper
+recordComponentModifier :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.RecordComponentModifier
+recordComponentModifier x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.RecordComponentModifier"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.RecordComponent
+recordComponentSimple :: Typed.TypedTerm Syntax.RecordComponent_Simple -> Typed.TypedTerm Syntax.RecordComponent
+recordComponentSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variableArity variant of hydra.java.syntax.RecordComponent
+recordComponentVariableArity :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm Syntax.RecordComponent
+recordComponentVariableArity x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variableArity"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.RecordComponent_Simple
+recordComponent_Simple :: Typed.TypedTerm [Syntax.RecordComponentModifier] -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.RecordComponent_Simple
+recordComponent_Simple modifiers type_ identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.RecordComponent_Simple
+recordComponent_SimpleIdentifier :: Typed.TypedTerm Syntax.RecordComponent_Simple -> Typed.TypedTerm Syntax.Identifier
+recordComponent_SimpleIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.RecordComponent_Simple
+recordComponent_SimpleModifiers :: Typed.TypedTerm Syntax.RecordComponent_Simple -> Typed.TypedTerm [Syntax.RecordComponentModifier]
+recordComponent_SimpleModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.RecordComponent_Simple
+recordComponent_SimpleType :: Typed.TypedTerm Syntax.RecordComponent_Simple -> Typed.TypedTerm Syntax.UnannType
+recordComponent_SimpleType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.RecordComponent_Simple
+recordComponent_SimpleWithIdentifier :: Typed.TypedTerm Syntax.RecordComponent_Simple -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.RecordComponent_Simple
+recordComponent_SimpleWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.RecordComponent_Simple"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.RecordComponent_Simple
+recordComponent_SimpleWithModifiers :: Typed.TypedTerm Syntax.RecordComponent_Simple -> Typed.TypedTerm [Syntax.RecordComponentModifier] -> Typed.TypedTerm Syntax.RecordComponent_Simple
+recordComponent_SimpleWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.RecordComponent_Simple"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.RecordComponent_Simple
+recordComponent_SimpleWithType :: Typed.TypedTerm Syntax.RecordComponent_Simple -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.RecordComponent_Simple
+recordComponent_SimpleWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordComponent_Simple"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.RecordDeclaration
+recordDeclaration :: Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.RecordHeader -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.RecordBody -> Typed.TypedTerm Syntax.RecordDeclaration
+recordDeclaration modifiers identifier parameters header implements body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm parameters)},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Typed.unTypedTerm header)},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Typed.unTypedTerm implements)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.RecordDeclaration
+recordDeclarationBody :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm Syntax.RecordBody
+recordDeclarationBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the header field of hydra.java.syntax.RecordDeclaration
+recordDeclarationHeader :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm Syntax.RecordHeader
+recordDeclarationHeader x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+        Core.projectionFieldName = (Core.Name "header")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.RecordDeclaration
+recordDeclarationIdentifier :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier
+recordDeclarationIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the implements field of hydra.java.syntax.RecordDeclaration
+recordDeclarationImplements :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm [Syntax.InterfaceType]
+recordDeclarationImplements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+        Core.projectionFieldName = (Core.Name "implements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.RecordDeclaration
+recordDeclarationModifiers :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm [Syntax.ClassModifier]
+recordDeclarationModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parameters field of hydra.java.syntax.RecordDeclaration
+recordDeclarationParameters :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm [Syntax.TypeParameter]
+recordDeclarationParameters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+        Core.projectionFieldName = (Core.Name "parameters")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.RecordDeclaration
+recordDeclarationWithBody :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm Syntax.RecordBody -> Typed.TypedTerm Syntax.RecordDeclaration
+recordDeclarationWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the header field of hydra.java.syntax.RecordDeclaration
+recordDeclarationWithHeader :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm Syntax.RecordHeader -> Typed.TypedTerm Syntax.RecordDeclaration
+recordDeclarationWithHeader original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            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.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.RecordDeclaration
+recordDeclarationWithIdentifier :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.RecordDeclaration
+recordDeclarationWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            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.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the implements field of hydra.java.syntax.RecordDeclaration
+recordDeclarationWithImplements :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.RecordDeclaration
+recordDeclarationWithImplements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          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.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.RecordDeclaration
+recordDeclarationWithModifiers :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Syntax.RecordDeclaration
+recordDeclarationWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "parameters")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            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.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the parameters field of hydra.java.syntax.RecordDeclaration
+recordDeclarationWithParameters :: Typed.TypedTerm Syntax.RecordDeclaration -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.RecordDeclaration
+recordDeclarationWithParameters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parameters"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "header"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "header")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "implements"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "implements")})),
+            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.java.syntax.RecordDeclaration"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.RecordHeader wrapper
+recordHeader :: Typed.TypedTerm [Syntax.RecordComponent] -> Typed.TypedTerm Syntax.RecordHeader
+recordHeader x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.RecordHeader"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.RecordPattern
+recordPattern :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.RecordPattern
+recordPattern type_ patterns =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordPattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "patterns"),
+          Core.fieldTerm = (Typed.unTypedTerm patterns)}]}))
+
+-- | DSL accessor for the patterns field of hydra.java.syntax.RecordPattern
+recordPatternPatterns :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm [Syntax.Pattern]
+recordPatternPatterns x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordPattern"),
+        Core.projectionFieldName = (Core.Name "patterns")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.RecordPattern
+recordPatternType :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm Syntax.ReferenceType
+recordPatternType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordPattern"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the patterns field of hydra.java.syntax.RecordPattern
+recordPatternWithPatterns :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.RecordPattern
+recordPatternWithPatterns original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordPattern"),
+      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.java.syntax.RecordPattern"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "patterns"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.RecordPattern
+recordPatternWithType :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.RecordPattern
+recordPatternWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RecordPattern"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "patterns"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.RecordPattern"),
+              Core.projectionFieldName = (Core.Name "patterns")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the array variant of hydra.java.syntax.ReferenceType
+referenceTypeArray :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ReferenceType
+referenceTypeArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ReferenceType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "array"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the classOrInterface variant of hydra.java.syntax.ReferenceType
+referenceTypeClassOrInterface :: Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm Syntax.ReferenceType
+referenceTypeClassOrInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ReferenceType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classOrInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variable variant of hydra.java.syntax.ReferenceType
+referenceTypeVariable :: Typed.TypedTerm Syntax.TypeVariable -> Typed.TypedTerm Syntax.ReferenceType
+referenceTypeVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ReferenceType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the greaterThan variant of hydra.java.syntax.RelationalExpression
+relationalExpressionGreaterThan :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThan -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpressionGreaterThan x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "greaterThan"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the greaterThanEqual variant of hydra.java.syntax.RelationalExpression
+relationalExpressionGreaterThanEqual :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThanEqual -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpressionGreaterThanEqual x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "greaterThanEqual"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the instanceofExpression variant of hydra.java.syntax.RelationalExpression
+relationalExpressionInstanceofExpression :: Typed.TypedTerm Syntax.InstanceofExpression -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpressionInstanceofExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "instanceofExpression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the lessThan variant of hydra.java.syntax.RelationalExpression
+relationalExpressionLessThan :: Typed.TypedTerm Syntax.RelationalExpression_LessThan -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpressionLessThan x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lessThan"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the lessThanEqual variant of hydra.java.syntax.RelationalExpression
+relationalExpressionLessThanEqual :: Typed.TypedTerm Syntax.RelationalExpression_LessThanEqual -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpressionLessThanEqual x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lessThanEqual"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.RelationalExpression
+relationalExpressionSimple :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpressionSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.RelationalExpression_GreaterThan
+relationalExpression_GreaterThan :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression_GreaterThan
+relationalExpression_GreaterThan lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThan"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL constructor for hydra.java.syntax.RelationalExpression_GreaterThanEqual
+relationalExpression_GreaterThanEqual :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression_GreaterThanEqual
+relationalExpression_GreaterThanEqual lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThanEqual"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.RelationalExpression_GreaterThanEqual
+relationalExpression_GreaterThanEqualLhs :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThanEqual -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpression_GreaterThanEqualLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThanEqual"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.RelationalExpression_GreaterThanEqual
+relationalExpression_GreaterThanEqualRhs :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThanEqual -> Typed.TypedTerm Syntax.ShiftExpression
+relationalExpression_GreaterThanEqualRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThanEqual"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.RelationalExpression_GreaterThanEqual
+relationalExpression_GreaterThanEqualWithLhs :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThanEqual -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression_GreaterThanEqual
+relationalExpression_GreaterThanEqualWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThanEqual"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.RelationalExpression_GreaterThanEqual"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.RelationalExpression_GreaterThanEqual
+relationalExpression_GreaterThanEqualWithRhs :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThanEqual -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression_GreaterThanEqual
+relationalExpression_GreaterThanEqualWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThanEqual"),
+      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.java.syntax.RelationalExpression_GreaterThanEqual"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.RelationalExpression_GreaterThan
+relationalExpression_GreaterThanLhs :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThan -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpression_GreaterThanLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThan"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.RelationalExpression_GreaterThan
+relationalExpression_GreaterThanRhs :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThan -> Typed.TypedTerm Syntax.ShiftExpression
+relationalExpression_GreaterThanRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThan"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.RelationalExpression_GreaterThan
+relationalExpression_GreaterThanWithLhs :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThan -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression_GreaterThan
+relationalExpression_GreaterThanWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThan"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.RelationalExpression_GreaterThan"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.RelationalExpression_GreaterThan
+relationalExpression_GreaterThanWithRhs :: Typed.TypedTerm Syntax.RelationalExpression_GreaterThan -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression_GreaterThan
+relationalExpression_GreaterThanWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_GreaterThan"),
+      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.java.syntax.RelationalExpression_GreaterThan"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.RelationalExpression_LessThan
+relationalExpression_LessThan :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression_LessThan
+relationalExpression_LessThan lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThan"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL constructor for hydra.java.syntax.RelationalExpression_LessThanEqual
+relationalExpression_LessThanEqual :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression_LessThanEqual
+relationalExpression_LessThanEqual lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThanEqual"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.RelationalExpression_LessThanEqual
+relationalExpression_LessThanEqualLhs :: Typed.TypedTerm Syntax.RelationalExpression_LessThanEqual -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpression_LessThanEqualLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThanEqual"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.RelationalExpression_LessThanEqual
+relationalExpression_LessThanEqualRhs :: Typed.TypedTerm Syntax.RelationalExpression_LessThanEqual -> Typed.TypedTerm Syntax.ShiftExpression
+relationalExpression_LessThanEqualRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThanEqual"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.RelationalExpression_LessThanEqual
+relationalExpression_LessThanEqualWithLhs :: Typed.TypedTerm Syntax.RelationalExpression_LessThanEqual -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression_LessThanEqual
+relationalExpression_LessThanEqualWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThanEqual"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.RelationalExpression_LessThanEqual"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.RelationalExpression_LessThanEqual
+relationalExpression_LessThanEqualWithRhs :: Typed.TypedTerm Syntax.RelationalExpression_LessThanEqual -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression_LessThanEqual
+relationalExpression_LessThanEqualWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThanEqual"),
+      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.java.syntax.RelationalExpression_LessThanEqual"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.RelationalExpression_LessThan
+relationalExpression_LessThanLhs :: Typed.TypedTerm Syntax.RelationalExpression_LessThan -> Typed.TypedTerm Syntax.RelationalExpression
+relationalExpression_LessThanLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThan"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.RelationalExpression_LessThan
+relationalExpression_LessThanRhs :: Typed.TypedTerm Syntax.RelationalExpression_LessThan -> Typed.TypedTerm Syntax.ShiftExpression
+relationalExpression_LessThanRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThan"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.RelationalExpression_LessThan
+relationalExpression_LessThanWithLhs :: Typed.TypedTerm Syntax.RelationalExpression_LessThan -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression_LessThan
+relationalExpression_LessThanWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThan"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.RelationalExpression_LessThan"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.RelationalExpression_LessThan
+relationalExpression_LessThanWithRhs :: Typed.TypedTerm Syntax.RelationalExpression_LessThan -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression_LessThan
+relationalExpression_LessThanWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.RelationalExpression_LessThan"),
+      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.java.syntax.RelationalExpression_LessThan"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the static variant of hydra.java.syntax.RequiresModifier
+requiresModifierStatic :: Typed.TypedTerm Syntax.RequiresModifier
+requiresModifierStatic =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RequiresModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "static"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the transitive variant of hydra.java.syntax.RequiresModifier
+requiresModifierTransitive :: Typed.TypedTerm Syntax.RequiresModifier
+requiresModifierTransitive =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.RequiresModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "transitive"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the local variant of hydra.java.syntax.Resource
+resourceLocal :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm Syntax.Resource
+resourceLocal x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Resource"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "local"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.ResourceSpecification wrapper
+resourceSpecification :: Typed.TypedTerm [Syntax.Resource] -> Typed.TypedTerm Syntax.ResourceSpecification
+resourceSpecification x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ResourceSpecification"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the variable variant of hydra.java.syntax.Resource
+resourceVariable :: Typed.TypedTerm Syntax.VariableAccess -> Typed.TypedTerm Syntax.Resource
+resourceVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Resource"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.Resource_Local
+resource_Local :: Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Resource_Local
+resource_Local modifiers type_ identifier expression =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.Resource_Local
+resource_LocalExpression :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm Syntax.Expression
+resource_LocalExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.Resource_Local
+resource_LocalIdentifier :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm Syntax.Identifier
+resource_LocalIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.Resource_Local
+resource_LocalModifiers :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm [Syntax.VariableModifier]
+resource_LocalModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.Resource_Local
+resource_LocalType :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm Syntax.LocalVariableType
+resource_LocalType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.Resource_Local
+resource_LocalWithExpression :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Resource_Local
+resource_LocalWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.Resource_Local
+resource_LocalWithIdentifier :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Resource_Local
+resource_LocalWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          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.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.Resource_Local
+resource_LocalWithModifiers :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.Resource_Local
+resource_LocalWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            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.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.Resource_Local
+resource_LocalWithType :: Typed.TypedTerm Syntax.Resource_Local -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.Resource_Local
+resource_LocalWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            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.java.syntax.Resource_Local"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the type variant of hydra.java.syntax.Result
+resultType :: Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.Result
+resultType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Result"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the void variant of hydra.java.syntax.Result
+resultVoid :: Typed.TypedTerm Syntax.Result
+resultVoid =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Result"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "void"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for the hydra.java.syntax.ReturnStatement wrapper
+returnStatement :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.ReturnStatement
+returnStatement x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ReturnStatement"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the shiftLeft variant of hydra.java.syntax.ShiftExpression
+shiftExpressionShiftLeft :: Typed.TypedTerm Syntax.ShiftExpression_Binary -> Typed.TypedTerm Syntax.ShiftExpression
+shiftExpressionShiftLeft x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ShiftExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "shiftLeft"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the shiftRight variant of hydra.java.syntax.ShiftExpression
+shiftExpressionShiftRight :: Typed.TypedTerm Syntax.ShiftExpression_Binary -> Typed.TypedTerm Syntax.ShiftExpression
+shiftExpressionShiftRight x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ShiftExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "shiftRight"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the shiftRightZeroFill variant of hydra.java.syntax.ShiftExpression
+shiftExpressionShiftRightZeroFill :: Typed.TypedTerm Syntax.ShiftExpression_Binary -> Typed.TypedTerm Syntax.ShiftExpression
+shiftExpressionShiftRightZeroFill x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ShiftExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "shiftRightZeroFill"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the unary variant of hydra.java.syntax.ShiftExpression
+shiftExpressionUnary :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.ShiftExpression
+shiftExpressionUnary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.ShiftExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.ShiftExpression_Binary
+shiftExpression_Binary :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.ShiftExpression_Binary
+shiftExpression_Binary lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ShiftExpression_Binary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.java.syntax.ShiftExpression_Binary
+shiftExpression_BinaryLhs :: Typed.TypedTerm Syntax.ShiftExpression_Binary -> Typed.TypedTerm Syntax.ShiftExpression
+shiftExpression_BinaryLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ShiftExpression_Binary"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.java.syntax.ShiftExpression_Binary
+shiftExpression_BinaryRhs :: Typed.TypedTerm Syntax.ShiftExpression_Binary -> Typed.TypedTerm Syntax.AdditiveExpression
+shiftExpression_BinaryRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.ShiftExpression_Binary"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.java.syntax.ShiftExpression_Binary
+shiftExpression_BinaryWithLhs :: Typed.TypedTerm Syntax.ShiftExpression_Binary -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.ShiftExpression_Binary
+shiftExpression_BinaryWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ShiftExpression_Binary"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          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.java.syntax.ShiftExpression_Binary"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.java.syntax.ShiftExpression_Binary
+shiftExpression_BinaryWithRhs :: Typed.TypedTerm Syntax.ShiftExpression_Binary -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.ShiftExpression_Binary
+shiftExpression_BinaryWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.ShiftExpression_Binary"),
+      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.java.syntax.ShiftExpression_Binary"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.java.syntax.SimpleTypeName wrapper
+simpleTypeName :: Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.SimpleTypeName
+simpleTypeName x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.SimpleTypeName"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.SingleElementAnnotation
+singleElementAnnotation :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm (Maybe Syntax.ElementValue) -> Typed.TypedTerm Syntax.SingleElementAnnotation
+singleElementAnnotation name value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SingleElementAnnotation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the name field of hydra.java.syntax.SingleElementAnnotation
+singleElementAnnotationName :: Typed.TypedTerm Syntax.SingleElementAnnotation -> Typed.TypedTerm Syntax.TypeName
+singleElementAnnotationName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SingleElementAnnotation"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.java.syntax.SingleElementAnnotation
+singleElementAnnotationValue :: Typed.TypedTerm Syntax.SingleElementAnnotation -> Typed.TypedTerm (Maybe Syntax.ElementValue)
+singleElementAnnotationValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SingleElementAnnotation"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.java.syntax.SingleElementAnnotation
+singleElementAnnotationWithName :: Typed.TypedTerm Syntax.SingleElementAnnotation -> Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.SingleElementAnnotation
+singleElementAnnotationWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SingleElementAnnotation"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SingleElementAnnotation"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the value field of hydra.java.syntax.SingleElementAnnotation
+singleElementAnnotationWithValue :: Typed.TypedTerm Syntax.SingleElementAnnotation -> Typed.TypedTerm (Maybe Syntax.ElementValue) -> Typed.TypedTerm Syntax.SingleElementAnnotation
+singleElementAnnotationWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SingleElementAnnotation"),
+      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.java.syntax.SingleElementAnnotation"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.SingleStaticImportDeclaration
+singleStaticImportDeclaration :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.SingleStaticImportDeclaration
+singleStaticImportDeclaration typeName identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeName"),
+          Core.fieldTerm = (Typed.unTypedTerm typeName)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.SingleStaticImportDeclaration
+singleStaticImportDeclarationIdentifier :: Typed.TypedTerm Syntax.SingleStaticImportDeclaration -> Typed.TypedTerm Syntax.Identifier
+singleStaticImportDeclarationIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeName field of hydra.java.syntax.SingleStaticImportDeclaration
+singleStaticImportDeclarationTypeName :: Typed.TypedTerm Syntax.SingleStaticImportDeclaration -> Typed.TypedTerm Syntax.TypeName
+singleStaticImportDeclarationTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"),
+        Core.projectionFieldName = (Core.Name "typeName")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.SingleStaticImportDeclaration
+singleStaticImportDeclarationWithIdentifier :: Typed.TypedTerm Syntax.SingleStaticImportDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.SingleStaticImportDeclaration
+singleStaticImportDeclarationWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeName"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"),
+              Core.projectionFieldName = (Core.Name "typeName")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the typeName field of hydra.java.syntax.SingleStaticImportDeclaration
+singleStaticImportDeclarationWithTypeName :: Typed.TypedTerm Syntax.SingleStaticImportDeclaration -> Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.SingleStaticImportDeclaration
+singleStaticImportDeclarationWithTypeName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeName"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.SingleTypeImportDeclaration wrapper
+singleTypeImportDeclaration :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.SingleTypeImportDeclaration
+singleTypeImportDeclaration x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.SingleTypeImportDeclaration"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the assignment variant of hydra.java.syntax.StatementExpression
+statementExpressionAssignment :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.StatementExpression
+statementExpressionAssignment x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "assignment"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the classInstanceCreation variant of hydra.java.syntax.StatementExpression
+statementExpressionClassInstanceCreation :: Typed.TypedTerm Syntax.ClassInstanceCreationExpression -> Typed.TypedTerm Syntax.StatementExpression
+statementExpressionClassInstanceCreation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classInstanceCreation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the methodInvocation variant of hydra.java.syntax.StatementExpression
+statementExpressionMethodInvocation :: Typed.TypedTerm Syntax.MethodInvocation -> Typed.TypedTerm Syntax.StatementExpression
+statementExpressionMethodInvocation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "methodInvocation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the postDecrement variant of hydra.java.syntax.StatementExpression
+statementExpressionPostDecrement :: Typed.TypedTerm Syntax.PostDecrementExpression -> Typed.TypedTerm Syntax.StatementExpression
+statementExpressionPostDecrement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "postDecrement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the postIncrement variant of hydra.java.syntax.StatementExpression
+statementExpressionPostIncrement :: Typed.TypedTerm Syntax.PostIncrementExpression -> Typed.TypedTerm Syntax.StatementExpression
+statementExpressionPostIncrement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "postIncrement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the preDecrement variant of hydra.java.syntax.StatementExpression
+statementExpressionPreDecrement :: Typed.TypedTerm Syntax.PreDecrementExpression -> Typed.TypedTerm Syntax.StatementExpression
+statementExpressionPreDecrement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "preDecrement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the preIncrement variant of hydra.java.syntax.StatementExpression
+statementExpressionPreIncrement :: Typed.TypedTerm Syntax.PreIncrementExpression -> Typed.TypedTerm Syntax.StatementExpression
+statementExpressionPreIncrement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "preIncrement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the for variant of hydra.java.syntax.Statement
+statementFor :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Statement
+statementFor x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "for"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ifThen variant of hydra.java.syntax.Statement
+statementIfThen :: Typed.TypedTerm Syntax.IfThenStatement -> Typed.TypedTerm Syntax.Statement
+statementIfThen x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ifThen"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ifThenElse variant of hydra.java.syntax.Statement
+statementIfThenElse :: Typed.TypedTerm Syntax.IfThenElseStatement -> Typed.TypedTerm Syntax.Statement
+statementIfThenElse x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ifThenElse"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the labeled variant of hydra.java.syntax.Statement
+statementLabeled :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement
+statementLabeled x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "labeled"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the for variant of hydra.java.syntax.StatementNoShortIf
+statementNoShortIfFor :: Typed.TypedTerm Syntax.ForStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+statementNoShortIfFor x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementNoShortIf"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "for"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ifThenElse variant of hydra.java.syntax.StatementNoShortIf
+statementNoShortIfIfThenElse :: Typed.TypedTerm Syntax.IfThenElseStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+statementNoShortIfIfThenElse x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementNoShortIf"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ifThenElse"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the labeled variant of hydra.java.syntax.StatementNoShortIf
+statementNoShortIfLabeled :: Typed.TypedTerm Syntax.LabeledStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+statementNoShortIfLabeled x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementNoShortIf"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "labeled"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the while variant of hydra.java.syntax.StatementNoShortIf
+statementNoShortIfWhile :: Typed.TypedTerm Syntax.WhileStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+statementNoShortIfWhile x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementNoShortIf"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "while"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the withoutTrailing variant of hydra.java.syntax.StatementNoShortIf
+statementNoShortIfWithoutTrailing :: Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement -> Typed.TypedTerm Syntax.StatementNoShortIf
+statementNoShortIfWithoutTrailing x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementNoShortIf"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "withoutTrailing"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the while variant of hydra.java.syntax.Statement
+statementWhile :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Statement
+statementWhile x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "while"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the withoutTrailing variant of hydra.java.syntax.Statement
+statementWithoutTrailing :: Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement -> Typed.TypedTerm Syntax.Statement
+statementWithoutTrailing x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Statement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "withoutTrailing"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the assert variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementAssert :: Typed.TypedTerm Syntax.AssertStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementAssert x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "assert"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the block variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementBlock x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "block"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the break variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementBreak :: Typed.TypedTerm Syntax.BreakStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementBreak x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "break"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the continue variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementContinue :: Typed.TypedTerm Syntax.ContinueStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementContinue x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "continue"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the do variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementDo :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementDo x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "do"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the empty variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementEmpty :: Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementEmpty =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "empty"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the expression variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementExpression :: Typed.TypedTerm Syntax.ExpressionStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the return variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementReturn :: Typed.TypedTerm Syntax.ReturnStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementReturn x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "return"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the switch variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementSwitch :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementSwitch x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "switch"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the synchronized variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementSynchronized :: Typed.TypedTerm Syntax.SynchronizedStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementSynchronized x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "synchronized"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the throw variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementThrow :: Typed.TypedTerm Syntax.ThrowStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementThrow x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "throw"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the try variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementTry :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementTry x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "try"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the yield variant of hydra.java.syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementYield :: Typed.TypedTerm Syntax.YieldStatement -> Typed.TypedTerm Syntax.StatementWithoutTrailingSubstatement
+statementWithoutTrailingSubstatementYield x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "yield"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for the hydra.java.syntax.StaticImportOnDemandDeclaration wrapper
+staticImportOnDemandDeclaration :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.StaticImportOnDemandDeclaration
+staticImportOnDemandDeclaration x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.StaticImportOnDemandDeclaration"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.StaticInitializer wrapper
+staticInitializer :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.StaticInitializer
+staticInitializer x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.StaticInitializer"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.StringLiteral wrapper
+stringLiteral :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.StringLiteral
+stringLiteral x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.StringLiteral"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the legacy variant of hydra.java.syntax.SwitchBlock
+switchBlockLegacy :: Typed.TypedTerm Syntax.SwitchBlock_Legacy -> Typed.TypedTerm Syntax.SwitchBlock
+switchBlockLegacy x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlock"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "legacy"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the rules variant of hydra.java.syntax.SwitchBlock
+switchBlockRules :: Typed.TypedTerm [Syntax.SwitchRule] -> Typed.TypedTerm Syntax.SwitchBlock
+switchBlockRules x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlock"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "rules"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.SwitchBlockStatementGroup
+switchBlockStatementGroup :: Typed.TypedTerm [Syntax.SwitchLabel] -> Typed.TypedTerm [Syntax.BlockStatement] -> Typed.TypedTerm Syntax.SwitchBlockStatementGroup
+switchBlockStatementGroup labels statements =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchBlockStatementGroup"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "labels"),
+          Core.fieldTerm = (Typed.unTypedTerm labels)},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm statements)}]}))
+
+-- | DSL accessor for the labels field of hydra.java.syntax.SwitchBlockStatementGroup
+switchBlockStatementGroupLabels :: Typed.TypedTerm Syntax.SwitchBlockStatementGroup -> Typed.TypedTerm [Syntax.SwitchLabel]
+switchBlockStatementGroupLabels x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlockStatementGroup"),
+        Core.projectionFieldName = (Core.Name "labels")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the statements field of hydra.java.syntax.SwitchBlockStatementGroup
+switchBlockStatementGroupStatements :: Typed.TypedTerm Syntax.SwitchBlockStatementGroup -> Typed.TypedTerm [Syntax.BlockStatement]
+switchBlockStatementGroupStatements x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlockStatementGroup"),
+        Core.projectionFieldName = (Core.Name "statements")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the labels field of hydra.java.syntax.SwitchBlockStatementGroup
+switchBlockStatementGroupWithLabels :: Typed.TypedTerm Syntax.SwitchBlockStatementGroup -> Typed.TypedTerm [Syntax.SwitchLabel] -> Typed.TypedTerm Syntax.SwitchBlockStatementGroup
+switchBlockStatementGroupWithLabels original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchBlockStatementGroup"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "labels"),
+          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.java.syntax.SwitchBlockStatementGroup"),
+              Core.projectionFieldName = (Core.Name "statements")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the statements field of hydra.java.syntax.SwitchBlockStatementGroup
+switchBlockStatementGroupWithStatements :: Typed.TypedTerm Syntax.SwitchBlockStatementGroup -> Typed.TypedTerm [Syntax.BlockStatement] -> Typed.TypedTerm Syntax.SwitchBlockStatementGroup
+switchBlockStatementGroupWithStatements original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchBlockStatementGroup"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "labels"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlockStatementGroup"),
+              Core.projectionFieldName = (Core.Name "labels")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "statements"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.SwitchBlock_Legacy
+switchBlock_Legacy :: Typed.TypedTerm [Syntax.SwitchBlockStatementGroup] -> Typed.TypedTerm [Syntax.SwitchLabel] -> Typed.TypedTerm Syntax.SwitchBlock_Legacy
+switchBlock_Legacy groups trailingLabels =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchBlock_Legacy"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "groups"),
+          Core.fieldTerm = (Typed.unTypedTerm groups)},
+        Core.Field {
+          Core.fieldName = (Core.Name "trailingLabels"),
+          Core.fieldTerm = (Typed.unTypedTerm trailingLabels)}]}))
+
+-- | DSL accessor for the groups field of hydra.java.syntax.SwitchBlock_Legacy
+switchBlock_LegacyGroups :: Typed.TypedTerm Syntax.SwitchBlock_Legacy -> Typed.TypedTerm [Syntax.SwitchBlockStatementGroup]
+switchBlock_LegacyGroups x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlock_Legacy"),
+        Core.projectionFieldName = (Core.Name "groups")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the trailingLabels field of hydra.java.syntax.SwitchBlock_Legacy
+switchBlock_LegacyTrailingLabels :: Typed.TypedTerm Syntax.SwitchBlock_Legacy -> Typed.TypedTerm [Syntax.SwitchLabel]
+switchBlock_LegacyTrailingLabels x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlock_Legacy"),
+        Core.projectionFieldName = (Core.Name "trailingLabels")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the groups field of hydra.java.syntax.SwitchBlock_Legacy
+switchBlock_LegacyWithGroups :: Typed.TypedTerm Syntax.SwitchBlock_Legacy -> Typed.TypedTerm [Syntax.SwitchBlockStatementGroup] -> Typed.TypedTerm Syntax.SwitchBlock_Legacy
+switchBlock_LegacyWithGroups original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchBlock_Legacy"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "groups"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "trailingLabels"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlock_Legacy"),
+              Core.projectionFieldName = (Core.Name "trailingLabels")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the trailingLabels field of hydra.java.syntax.SwitchBlock_Legacy
+switchBlock_LegacyWithTrailingLabels :: Typed.TypedTerm Syntax.SwitchBlock_Legacy -> Typed.TypedTerm [Syntax.SwitchLabel] -> Typed.TypedTerm Syntax.SwitchBlock_Legacy
+switchBlock_LegacyWithTrailingLabels original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchBlock_Legacy"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "groups"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchBlock_Legacy"),
+              Core.projectionFieldName = (Core.Name "groups")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "trailingLabels"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.SwitchExpression
+switchExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SwitchBlock -> Typed.TypedTerm Syntax.SwitchExpression
+switchExpression cond block =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm block)}]}))
+
+-- | DSL accessor for the block field of hydra.java.syntax.SwitchExpression
+switchExpressionBlock :: Typed.TypedTerm Syntax.SwitchExpression -> Typed.TypedTerm Syntax.SwitchBlock
+switchExpressionBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchExpression"),
+        Core.projectionFieldName = (Core.Name "block")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.SwitchExpression
+switchExpressionCond :: Typed.TypedTerm Syntax.SwitchExpression -> Typed.TypedTerm Syntax.Expression
+switchExpressionCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchExpression"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the block field of hydra.java.syntax.SwitchExpression
+switchExpressionWithBlock :: Typed.TypedTerm Syntax.SwitchExpression -> Typed.TypedTerm Syntax.SwitchBlock -> Typed.TypedTerm Syntax.SwitchExpression
+switchExpressionWithBlock original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchExpression"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.SwitchExpression
+switchExpressionWithCond :: Typed.TypedTerm Syntax.SwitchExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SwitchExpression
+switchExpressionWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchExpression"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the case variant of hydra.java.syntax.SwitchLabel
+switchLabelCase :: Typed.TypedTerm [Syntax.CaseConstant] -> Typed.TypedTerm Syntax.SwitchLabel
+switchLabelCase x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchLabel"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "case"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the casePattern variant of hydra.java.syntax.SwitchLabel
+switchLabelCasePattern :: Typed.TypedTerm Syntax.CasePattern -> Typed.TypedTerm Syntax.SwitchLabel
+switchLabelCasePattern x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchLabel"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "casePattern"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the default variant of hydra.java.syntax.SwitchLabel
+switchLabelDefault :: Typed.TypedTerm Syntax.SwitchLabel
+switchLabelDefault =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchLabel"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "default"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the null variant of hydra.java.syntax.SwitchLabel
+switchLabelNull :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.SwitchLabel
+switchLabelNull x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchLabel"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "null"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.SwitchRule
+switchRule :: Typed.TypedTerm Syntax.SwitchLabel -> Typed.TypedTerm Syntax.SwitchRule_Body -> Typed.TypedTerm Syntax.SwitchRule
+switchRule label body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchRule"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "label"),
+          Core.fieldTerm = (Typed.unTypedTerm label)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.SwitchRule
+switchRuleBody :: Typed.TypedTerm Syntax.SwitchRule -> Typed.TypedTerm Syntax.SwitchRule_Body
+switchRuleBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchRule"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the label field of hydra.java.syntax.SwitchRule
+switchRuleLabel :: Typed.TypedTerm Syntax.SwitchRule -> Typed.TypedTerm Syntax.SwitchLabel
+switchRuleLabel x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchRule"),
+        Core.projectionFieldName = (Core.Name "label")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.SwitchRule
+switchRuleWithBody :: Typed.TypedTerm Syntax.SwitchRule -> Typed.TypedTerm Syntax.SwitchRule_Body -> Typed.TypedTerm Syntax.SwitchRule
+switchRuleWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchRule"),
+      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.java.syntax.SwitchRule"),
+              Core.projectionFieldName = (Core.Name "label")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the label field of hydra.java.syntax.SwitchRule
+switchRuleWithLabel :: Typed.TypedTerm Syntax.SwitchRule -> Typed.TypedTerm Syntax.SwitchLabel -> Typed.TypedTerm Syntax.SwitchRule
+switchRuleWithLabel original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchRule"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "label"),
+          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.java.syntax.SwitchRule"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the block variant of hydra.java.syntax.SwitchRule_Body
+switchRule_BodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.SwitchRule_Body
+switchRule_BodyBlock x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchRule_Body"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "block"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the expression variant of hydra.java.syntax.SwitchRule_Body
+switchRule_BodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SwitchRule_Body
+switchRule_BodyExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchRule_Body"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the throw variant of hydra.java.syntax.SwitchRule_Body
+switchRule_BodyThrow :: Typed.TypedTerm Syntax.ThrowStatement -> Typed.TypedTerm Syntax.SwitchRule_Body
+switchRule_BodyThrow x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.SwitchRule_Body"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "throw"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.SwitchStatement
+switchStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SwitchBlock -> Typed.TypedTerm Syntax.SwitchStatement
+switchStatement cond block =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm block)}]}))
+
+-- | DSL accessor for the block field of hydra.java.syntax.SwitchStatement
+switchStatementBlock :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.SwitchBlock
+switchStatementBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchStatement"),
+        Core.projectionFieldName = (Core.Name "block")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.SwitchStatement
+switchStatementCond :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Expression
+switchStatementCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchStatement"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the block field of hydra.java.syntax.SwitchStatement
+switchStatementWithBlock :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.SwitchBlock -> Typed.TypedTerm Syntax.SwitchStatement
+switchStatementWithBlock original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchStatement"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.SwitchStatement
+switchStatementWithCond :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SwitchStatement
+switchStatementWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SwitchStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SwitchStatement"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.SynchronizedStatement
+synchronizedStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.SynchronizedStatement
+synchronizedStatement expression block =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SynchronizedStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm expression)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm block)}]}))
+
+-- | DSL accessor for the block field of hydra.java.syntax.SynchronizedStatement
+synchronizedStatementBlock :: Typed.TypedTerm Syntax.SynchronizedStatement -> Typed.TypedTerm Syntax.Block
+synchronizedStatementBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SynchronizedStatement"),
+        Core.projectionFieldName = (Core.Name "block")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expression field of hydra.java.syntax.SynchronizedStatement
+synchronizedStatementExpression :: Typed.TypedTerm Syntax.SynchronizedStatement -> Typed.TypedTerm Syntax.Expression
+synchronizedStatementExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.SynchronizedStatement"),
+        Core.projectionFieldName = (Core.Name "expression")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the block field of hydra.java.syntax.SynchronizedStatement
+synchronizedStatementWithBlock :: Typed.TypedTerm Syntax.SynchronizedStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.SynchronizedStatement
+synchronizedStatementWithBlock original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SynchronizedStatement"),
+      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.java.syntax.SynchronizedStatement"),
+              Core.projectionFieldName = (Core.Name "expression")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the expression field of hydra.java.syntax.SynchronizedStatement
+synchronizedStatementWithExpression :: Typed.TypedTerm Syntax.SynchronizedStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SynchronizedStatement
+synchronizedStatementWithExpression original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.SynchronizedStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expression"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.SynchronizedStatement"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.TextBlock wrapper
+textBlock :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.TextBlock
+textBlock x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.TextBlock"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.ThrowStatement wrapper
+throwStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ThrowStatement
+throwStatement x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.ThrowStatement"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.Throws wrapper
+throws :: Typed.TypedTerm [Syntax.ExceptionType] -> Typed.TypedTerm Syntax.Throws
+throws x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.Throws"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the class variant of hydra.java.syntax.TopLevelClassOrInterfaceDeclaration
+topLevelClassOrInterfaceDeclarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclaration
+topLevelClassOrInterfaceDeclarationClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interface variant of hydra.java.syntax.TopLevelClassOrInterfaceDeclaration
+topLevelClassOrInterfaceDeclarationInterface :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclaration
+topLevelClassOrInterfaceDeclarationInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the none variant of hydra.java.syntax.TopLevelClassOrInterfaceDeclaration
+topLevelClassOrInterfaceDeclarationNone :: Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclaration
+topLevelClassOrInterfaceDeclarationNone =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclaration"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "none"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments
+topLevelClassOrInterfaceDeclarationWithComments :: Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclaration -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclarationWithComments
+topLevelClassOrInterfaceDeclarationWithComments value comments =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Typed.unTypedTerm comments)}]}))
+
+-- | DSL accessor for the comments field of hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments
+topLevelClassOrInterfaceDeclarationWithCommentsComments :: Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclarationWithComments -> Typed.TypedTerm (Maybe String)
+topLevelClassOrInterfaceDeclarationWithCommentsComments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"),
+        Core.projectionFieldName = (Core.Name "comments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the value field of hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments
+topLevelClassOrInterfaceDeclarationWithCommentsValue :: Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclarationWithComments -> Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclaration
+topLevelClassOrInterfaceDeclarationWithCommentsValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the comments field of hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments
+topLevelClassOrInterfaceDeclarationWithCommentsWithComments :: Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclarationWithComments -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclarationWithComments
+topLevelClassOrInterfaceDeclarationWithCommentsWithComments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"),
+              Core.projectionFieldName = (Core.Name "value")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the value field of hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments
+topLevelClassOrInterfaceDeclarationWithCommentsWithValue :: Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclarationWithComments -> Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclaration -> Typed.TypedTerm Syntax.TopLevelClassOrInterfaceDeclarationWithComments
+topLevelClassOrInterfaceDeclarationWithCommentsWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "comments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"),
+              Core.projectionFieldName = (Core.Name "comments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.TryStatement
+tryStatementSimple :: Typed.TypedTerm Syntax.TryStatement_Simple -> Typed.TypedTerm Syntax.TryStatement
+tryStatementSimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TryStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the withFinally variant of hydra.java.syntax.TryStatement
+tryStatementWithFinally :: Typed.TypedTerm Syntax.TryStatement_WithFinally -> Typed.TypedTerm Syntax.TryStatement
+tryStatementWithFinally x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TryStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "withFinally"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the withResources variant of hydra.java.syntax.TryStatement
+tryStatementWithResources :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm Syntax.TryStatement
+tryStatementWithResources x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TryStatement"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "withResources"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.TryStatement_Simple
+tryStatement_Simple :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.Catches -> Typed.TypedTerm Syntax.TryStatement_Simple
+tryStatement_Simple block catches =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryStatement_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm block)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Typed.unTypedTerm catches)}]}))
+
+-- | DSL accessor for the block field of hydra.java.syntax.TryStatement_Simple
+tryStatement_SimpleBlock :: Typed.TypedTerm Syntax.TryStatement_Simple -> Typed.TypedTerm Syntax.Block
+tryStatement_SimpleBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_Simple"),
+        Core.projectionFieldName = (Core.Name "block")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the catches field of hydra.java.syntax.TryStatement_Simple
+tryStatement_SimpleCatches :: Typed.TypedTerm Syntax.TryStatement_Simple -> Typed.TypedTerm Syntax.Catches
+tryStatement_SimpleCatches x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_Simple"),
+        Core.projectionFieldName = (Core.Name "catches")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the block field of hydra.java.syntax.TryStatement_Simple
+tryStatement_SimpleWithBlock :: Typed.TypedTerm Syntax.TryStatement_Simple -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryStatement_Simple
+tryStatement_SimpleWithBlock original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryStatement_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_Simple"),
+              Core.projectionFieldName = (Core.Name "catches")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the catches field of hydra.java.syntax.TryStatement_Simple
+tryStatement_SimpleWithCatches :: Typed.TypedTerm Syntax.TryStatement_Simple -> Typed.TypedTerm Syntax.Catches -> Typed.TypedTerm Syntax.TryStatement_Simple
+tryStatement_SimpleWithCatches original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryStatement_Simple"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_Simple"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.TryStatement_WithFinally
+tryStatement_WithFinally :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.Catches) -> Typed.TypedTerm Syntax.Finally -> Typed.TypedTerm Syntax.TryStatement_WithFinally
+tryStatement_WithFinally block catches finally =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm block)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Typed.unTypedTerm catches)},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Typed.unTypedTerm finally)}]}))
+
+-- | DSL accessor for the block field of hydra.java.syntax.TryStatement_WithFinally
+tryStatement_WithFinallyBlock :: Typed.TypedTerm Syntax.TryStatement_WithFinally -> Typed.TypedTerm Syntax.Block
+tryStatement_WithFinallyBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+        Core.projectionFieldName = (Core.Name "block")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the catches field of hydra.java.syntax.TryStatement_WithFinally
+tryStatement_WithFinallyCatches :: Typed.TypedTerm Syntax.TryStatement_WithFinally -> Typed.TypedTerm (Maybe Syntax.Catches)
+tryStatement_WithFinallyCatches x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+        Core.projectionFieldName = (Core.Name "catches")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the finally field of hydra.java.syntax.TryStatement_WithFinally
+tryStatement_WithFinallyFinally :: Typed.TypedTerm Syntax.TryStatement_WithFinally -> Typed.TypedTerm Syntax.Finally
+tryStatement_WithFinallyFinally x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+        Core.projectionFieldName = (Core.Name "finally")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the block field of hydra.java.syntax.TryStatement_WithFinally
+tryStatement_WithFinallyWithBlock :: Typed.TypedTerm Syntax.TryStatement_WithFinally -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryStatement_WithFinally
+tryStatement_WithFinallyWithBlock original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+              Core.projectionFieldName = (Core.Name "catches")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+              Core.projectionFieldName = (Core.Name "finally")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the catches field of hydra.java.syntax.TryStatement_WithFinally
+tryStatement_WithFinallyWithCatches :: Typed.TypedTerm Syntax.TryStatement_WithFinally -> Typed.TypedTerm (Maybe Syntax.Catches) -> Typed.TypedTerm Syntax.TryStatement_WithFinally
+tryStatement_WithFinallyWithCatches original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+              Core.projectionFieldName = (Core.Name "finally")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the finally field of hydra.java.syntax.TryStatement_WithFinally
+tryStatement_WithFinallyWithFinally :: Typed.TypedTerm Syntax.TryStatement_WithFinally -> Typed.TypedTerm Syntax.Finally -> Typed.TypedTerm Syntax.TryStatement_WithFinally
+tryStatement_WithFinallyWithFinally original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryStatement_WithFinally"),
+              Core.projectionFieldName = (Core.Name "catches")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatement :: Typed.TypedTerm Syntax.ResourceSpecification -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.Catches) -> Typed.TypedTerm (Maybe Syntax.Finally) -> Typed.TypedTerm Syntax.TryWithResourcesStatement
+tryWithResourcesStatement resourceSpecification block catches finally =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "resourceSpecification"),
+          Core.fieldTerm = (Typed.unTypedTerm resourceSpecification)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm block)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Typed.unTypedTerm catches)},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Typed.unTypedTerm finally)}]}))
+
+-- | DSL accessor for the block field of hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatementBlock :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm Syntax.Block
+tryWithResourcesStatementBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+        Core.projectionFieldName = (Core.Name "block")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the catches field of hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatementCatches :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm (Maybe Syntax.Catches)
+tryWithResourcesStatementCatches x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+        Core.projectionFieldName = (Core.Name "catches")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the finally field of hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatementFinally :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm (Maybe Syntax.Finally)
+tryWithResourcesStatementFinally x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+        Core.projectionFieldName = (Core.Name "finally")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the resourceSpecification field of hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatementResourceSpecification :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm Syntax.ResourceSpecification
+tryWithResourcesStatementResourceSpecification x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+        Core.projectionFieldName = (Core.Name "resourceSpecification")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the block field of hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatementWithBlock :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryWithResourcesStatement
+tryWithResourcesStatementWithBlock original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "resourceSpecification"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "resourceSpecification")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "catches")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "finally")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the catches field of hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatementWithCatches :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm (Maybe Syntax.Catches) -> Typed.TypedTerm Syntax.TryWithResourcesStatement
+tryWithResourcesStatementWithCatches original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "resourceSpecification"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "resourceSpecification")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "finally")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the finally field of hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatementWithFinally :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm (Maybe Syntax.Finally) -> Typed.TypedTerm Syntax.TryWithResourcesStatement
+tryWithResourcesStatementWithFinally original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "resourceSpecification"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "resourceSpecification")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "catches")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the resourceSpecification field of hydra.java.syntax.TryWithResourcesStatement
+tryWithResourcesStatementWithResourceSpecification :: Typed.TypedTerm Syntax.TryWithResourcesStatement -> Typed.TypedTerm Syntax.ResourceSpecification -> Typed.TypedTerm Syntax.TryWithResourcesStatement
+tryWithResourcesStatementWithResourceSpecification original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "resourceSpecification"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "block"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "block")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catches"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "catches")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finally"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TryWithResourcesStatement"),
+              Core.projectionFieldName = (Core.Name "finally")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the reference variant of hydra.java.syntax.TypeArgument
+typeArgumentReference :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.TypeArgument
+typeArgumentReference x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TypeArgument"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "reference"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the wildcard variant of hydra.java.syntax.TypeArgument
+typeArgumentWildcard :: Typed.TypedTerm Syntax.Wildcard -> Typed.TypedTerm Syntax.TypeArgument
+typeArgumentWildcard x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TypeArgument"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "wildcard"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the arguments variant of hydra.java.syntax.TypeArgumentsOrDiamond
+typeArgumentsOrDiamondArguments :: Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.TypeArgumentsOrDiamond
+typeArgumentsOrDiamondArguments x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TypeArgumentsOrDiamond"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "arguments"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the diamond variant of hydra.java.syntax.TypeArgumentsOrDiamond
+typeArgumentsOrDiamondDiamond :: Typed.TypedTerm Syntax.TypeArgumentsOrDiamond
+typeArgumentsOrDiamondDiamond =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TypeArgumentsOrDiamond"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "diamond"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the classOrInterface variant of hydra.java.syntax.TypeBound
+typeBoundClassOrInterface :: Typed.TypedTerm Syntax.TypeBound_ClassOrInterface -> Typed.TypedTerm Syntax.TypeBound
+typeBoundClassOrInterface x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TypeBound"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "classOrInterface"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the variable variant of hydra.java.syntax.TypeBound
+typeBoundVariable :: Typed.TypedTerm Syntax.TypeVariable -> Typed.TypedTerm Syntax.TypeBound
+typeBoundVariable x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TypeBound"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "variable"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.TypeBound_ClassOrInterface
+typeBound_ClassOrInterface :: Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm [Syntax.AdditionalBound] -> Typed.TypedTerm Syntax.TypeBound_ClassOrInterface
+typeBound_ClassOrInterface type_ additional =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeBound_ClassOrInterface"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "additional"),
+          Core.fieldTerm = (Typed.unTypedTerm additional)}]}))
+
+-- | DSL accessor for the additional field of hydra.java.syntax.TypeBound_ClassOrInterface
+typeBound_ClassOrInterfaceAdditional :: Typed.TypedTerm Syntax.TypeBound_ClassOrInterface -> Typed.TypedTerm [Syntax.AdditionalBound]
+typeBound_ClassOrInterfaceAdditional x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeBound_ClassOrInterface"),
+        Core.projectionFieldName = (Core.Name "additional")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.TypeBound_ClassOrInterface
+typeBound_ClassOrInterfaceType :: Typed.TypedTerm Syntax.TypeBound_ClassOrInterface -> Typed.TypedTerm Syntax.ClassOrInterfaceType
+typeBound_ClassOrInterfaceType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeBound_ClassOrInterface"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the additional field of hydra.java.syntax.TypeBound_ClassOrInterface
+typeBound_ClassOrInterfaceWithAdditional :: Typed.TypedTerm Syntax.TypeBound_ClassOrInterface -> Typed.TypedTerm [Syntax.AdditionalBound] -> Typed.TypedTerm Syntax.TypeBound_ClassOrInterface
+typeBound_ClassOrInterfaceWithAdditional original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeBound_ClassOrInterface"),
+      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.java.syntax.TypeBound_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "additional"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.TypeBound_ClassOrInterface
+typeBound_ClassOrInterfaceWithType :: Typed.TypedTerm Syntax.TypeBound_ClassOrInterface -> Typed.TypedTerm Syntax.ClassOrInterfaceType -> Typed.TypedTerm Syntax.TypeBound_ClassOrInterface
+typeBound_ClassOrInterfaceWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeBound_ClassOrInterface"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "additional"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeBound_ClassOrInterface"),
+              Core.projectionFieldName = (Core.Name "additional")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.TypeIdentifier wrapper
+typeIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.TypeIdentifier
+typeIdentifier x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.TypeIdentifier"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.TypeImportOnDemandDeclaration wrapper
+typeImportOnDemandDeclaration :: Typed.TypedTerm Syntax.PackageOrTypeName -> Typed.TypedTerm Syntax.TypeImportOnDemandDeclaration
+typeImportOnDemandDeclaration x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.TypeImportOnDemandDeclaration"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.TypeName
+typeName :: Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm (Maybe Syntax.PackageOrTypeName) -> Typed.TypedTerm Syntax.TypeName
+typeName identifier qualifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm qualifier)}]}))
+
+-- | DSL injection for the array variant of hydra.java.syntax.TypeNameArray
+typeNameArrayArray :: Typed.TypedTerm Syntax.TypeNameArray -> Typed.TypedTerm Syntax.TypeNameArray
+typeNameArrayArray x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TypeNameArray"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "array"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the simple variant of hydra.java.syntax.TypeNameArray
+typeNameArraySimple :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.TypeNameArray
+typeNameArraySimple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.TypeNameArray"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "simple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.TypeName
+typeNameIdentifier :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.TypeIdentifier
+typeNameIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeName"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the qualifier field of hydra.java.syntax.TypeName
+typeNameQualifier :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm (Maybe Syntax.PackageOrTypeName)
+typeNameQualifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeName"),
+        Core.projectionFieldName = (Core.Name "qualifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.TypeName
+typeNameWithIdentifier :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.TypeName
+typeNameWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeName"),
+              Core.projectionFieldName = (Core.Name "qualifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the qualifier field of hydra.java.syntax.TypeName
+typeNameWithQualifier :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm (Maybe Syntax.PackageOrTypeName) -> Typed.TypedTerm Syntax.TypeName
+typeNameWithQualifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeName"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeName"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "qualifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.java.syntax.TypeParameter
+typeParameter :: Typed.TypedTerm [Syntax.TypeParameterModifier] -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm (Maybe Syntax.TypeBound) -> Typed.TypedTerm Syntax.TypeParameter
+typeParameter modifiers identifier bound =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bound"),
+          Core.fieldTerm = (Typed.unTypedTerm bound)}]}))
+
+-- | DSL accessor for the bound field of hydra.java.syntax.TypeParameter
+typeParameterBound :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm (Maybe Syntax.TypeBound)
+typeParameterBound x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+        Core.projectionFieldName = (Core.Name "bound")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.TypeParameter
+typeParameterIdentifier :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.TypeIdentifier
+typeParameterIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.TypeParameterModifier wrapper
+typeParameterModifier :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.TypeParameterModifier
+typeParameterModifier x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.TypeParameterModifier"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.TypeParameter
+typeParameterModifiers :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm [Syntax.TypeParameterModifier]
+typeParameterModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the bound field of hydra.java.syntax.TypeParameter
+typeParameterWithBound :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm (Maybe Syntax.TypeBound) -> Typed.TypedTerm Syntax.TypeParameter
+typeParameterWithBound original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bound"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.TypeParameter
+typeParameterWithIdentifier :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.TypeParameter
+typeParameterWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bound"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+              Core.projectionFieldName = (Core.Name "bound")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.TypeParameter
+typeParameterWithModifiers :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm [Syntax.TypeParameterModifier] -> Typed.TypedTerm Syntax.TypeParameter
+typeParameterWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bound"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeParameter"),
+              Core.projectionFieldName = (Core.Name "bound")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.java.syntax.TypePattern wrapper
+typePattern :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.TypePattern
+typePattern x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.TypePattern"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the primitive variant of hydra.java.syntax.Type
+typePrimitive :: Typed.TypedTerm Syntax.PrimitiveTypeWithAnnotations -> Typed.TypedTerm Syntax.Type
+typePrimitive x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primitive"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the reference variant of hydra.java.syntax.Type
+typeReference :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.Type
+typeReference x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "reference"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.TypeVariable
+typeVariable :: Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.TypeVariable
+typeVariable annotations identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeVariable"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.TypeVariable
+typeVariableAnnotations :: Typed.TypedTerm Syntax.TypeVariable -> Typed.TypedTerm [Syntax.Annotation]
+typeVariableAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeVariable"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.TypeVariable
+typeVariableIdentifier :: Typed.TypedTerm Syntax.TypeVariable -> Typed.TypedTerm Syntax.TypeIdentifier
+typeVariableIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeVariable"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.TypeVariable
+typeVariableWithAnnotations :: Typed.TypedTerm Syntax.TypeVariable -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.TypeVariable
+typeVariableWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeVariable"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeVariable"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.TypeVariable
+typeVariableWithIdentifier :: Typed.TypedTerm Syntax.TypeVariable -> Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.TypeVariable
+typeVariableWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.TypeVariable"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.TypeVariable"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL accessor for the body of hydra.java.syntax.AdditionalBound
+unAdditionalBound :: Typed.TypedTerm Syntax.AdditionalBound -> Typed.TypedTerm Syntax.InterfaceType
+unAdditionalBound x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.AdditionalBound")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.AmbiguousName
+unAmbiguousName :: Typed.TypedTerm Syntax.AmbiguousName -> Typed.TypedTerm [Syntax.Identifier]
+unAmbiguousName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.AmbiguousName")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.AndExpression
+unAndExpression :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm [Syntax.EqualityExpression]
+unAndExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.AndExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.AnnotationInterfaceBody
+unAnnotationInterfaceBody :: Typed.TypedTerm Syntax.AnnotationInterfaceBody -> Typed.TypedTerm [Syntax.AnnotationInterfaceMemberDeclaration]
+unAnnotationInterfaceBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.AnnotationInterfaceBody")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ArrayInitializer
+unArrayInitializer :: Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm [[Syntax.VariableInitializer]]
+unArrayInitializer x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ArrayInitializer")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.Block
+unBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm [Syntax.BlockStatement]
+unBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.Block")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.BreakStatement
+unBreakStatement :: Typed.TypedTerm Syntax.BreakStatement -> Typed.TypedTerm (Maybe Syntax.Identifier)
+unBreakStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.BreakStatement")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.CaseConstant
+unCaseConstant :: Typed.TypedTerm Syntax.CaseConstant -> Typed.TypedTerm Syntax.ConditionalExpression
+unCaseConstant x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.CaseConstant")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.Catches
+unCatches :: Typed.TypedTerm Syntax.Catches -> Typed.TypedTerm [Syntax.CatchClause]
+unCatches x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.Catches")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ClassBody
+unClassBody :: Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm [Syntax.ClassBodyDeclarationWithComments]
+unClassBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ClassBody")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ConditionalAndExpression
+unConditionalAndExpression :: Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm [Syntax.InclusiveOrExpression]
+unConditionalAndExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ConditionalAndExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ConditionalOrExpression
+unConditionalOrExpression :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm [Syntax.ConditionalAndExpression]
+unConditionalOrExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ConditionalOrExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ConstantExpression
+unConstantExpression :: Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.Expression
+unConstantExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ConstantExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ContinueStatement
+unContinueStatement :: Typed.TypedTerm Syntax.ContinueStatement -> Typed.TypedTerm (Maybe Syntax.Identifier)
+unContinueStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ContinueStatement")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.DefaultValue
+unDefaultValue :: Typed.TypedTerm Syntax.DefaultValue -> Typed.TypedTerm Syntax.ElementValue
+unDefaultValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.DefaultValue")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.Dims
+unDims :: Typed.TypedTerm Syntax.Dims -> Typed.TypedTerm [[Syntax.Annotation]]
+unDims x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.Dims")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ElementValueArrayInitializer
+unElementValueArrayInitializer :: Typed.TypedTerm Syntax.ElementValueArrayInitializer -> Typed.TypedTerm [Syntax.ElementValue]
+unElementValueArrayInitializer x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ElementValueArrayInitializer")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.EnumBody
+unEnumBody :: Typed.TypedTerm Syntax.EnumBody -> Typed.TypedTerm [Syntax.EnumBody_Element]
+unEnumBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.EnumBody")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.EnumConstantModifier
+unEnumConstantModifier :: Typed.TypedTerm Syntax.EnumConstantModifier -> Typed.TypedTerm Syntax.Annotation
+unEnumConstantModifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.EnumConstantModifier")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ExclusiveOrExpression
+unExclusiveOrExpression :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm [Syntax.AndExpression]
+unExclusiveOrExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ExclusiveOrExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ExpressionStatement
+unExpressionStatement :: Typed.TypedTerm Syntax.ExpressionStatement -> Typed.TypedTerm Syntax.StatementExpression
+unExpressionStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ExpressionStatement")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.Finally
+unFinally :: Typed.TypedTerm Syntax.Finally -> Typed.TypedTerm Syntax.Block
+unFinally x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.Finally")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.FloatingPointLiteral
+unFloatingPointLiteral :: Typed.TypedTerm Syntax.FloatingPointLiteral -> Typed.TypedTerm Double
+unFloatingPointLiteral x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.FloatingPointLiteral")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ForUpdate
+unForUpdate :: Typed.TypedTerm Syntax.ForUpdate -> Typed.TypedTerm [Syntax.StatementExpression]
+unForUpdate x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ForUpdate")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.Guard
+unGuard :: Typed.TypedTerm Syntax.Guard -> Typed.TypedTerm Syntax.Expression
+unGuard x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.Guard")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.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.java.syntax.Identifier")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.InclusiveOrExpression
+unInclusiveOrExpression :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm [Syntax.ExclusiveOrExpression]
+unInclusiveOrExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.InclusiveOrExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.InstanceInitializer
+unInstanceInitializer :: Typed.TypedTerm Syntax.InstanceInitializer -> Typed.TypedTerm Syntax.Block
+unInstanceInitializer x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.InstanceInitializer")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.IntegerLiteral
+unIntegerLiteral :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Integer
+unIntegerLiteral x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.IntegerLiteral")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.InterfaceBody
+unInterfaceBody :: Typed.TypedTerm Syntax.InterfaceBody -> Typed.TypedTerm [Syntax.InterfaceMemberDeclarationWithComments]
+unInterfaceBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.InterfaceBody")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.InterfaceType
+unInterfaceType :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.ClassType
+unInterfaceType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.InterfaceType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.LocalVariableDeclarationStatement
+unLocalVariableDeclarationStatement :: Typed.TypedTerm Syntax.LocalVariableDeclarationStatement -> Typed.TypedTerm Syntax.LocalVariableDeclaration
+unLocalVariableDeclarationStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.LocalVariableDeclarationStatement")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.MarkerAnnotation
+unMarkerAnnotation :: Typed.TypedTerm Syntax.MarkerAnnotation -> Typed.TypedTerm Syntax.TypeName
+unMarkerAnnotation x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.MarkerAnnotation")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.MethodName
+unMethodName :: Typed.TypedTerm Syntax.MethodName -> Typed.TypedTerm Syntax.Identifier
+unMethodName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.MethodName")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.MethodReference_Array
+unMethodReference_Array :: Typed.TypedTerm Syntax.MethodReference_Array -> Typed.TypedTerm Syntax.ArrayType
+unMethodReference_Array x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.MethodReference_Array")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.PackageModifier
+unPackageModifier :: Typed.TypedTerm Syntax.PackageModifier -> Typed.TypedTerm Syntax.Annotation
+unPackageModifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.PackageModifier")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.PackageName
+unPackageName :: Typed.TypedTerm Syntax.PackageName -> Typed.TypedTerm [Syntax.Identifier]
+unPackageName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.PackageName")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.PackageOrTypeName
+unPackageOrTypeName :: Typed.TypedTerm Syntax.PackageOrTypeName -> Typed.TypedTerm [Syntax.Identifier]
+unPackageOrTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.PackageOrTypeName")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.PostDecrementExpression
+unPostDecrementExpression :: Typed.TypedTerm Syntax.PostDecrementExpression -> Typed.TypedTerm Syntax.PostfixExpression
+unPostDecrementExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.PostDecrementExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.PostIncrementExpression
+unPostIncrementExpression :: Typed.TypedTerm Syntax.PostIncrementExpression -> Typed.TypedTerm Syntax.PostfixExpression
+unPostIncrementExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.PostIncrementExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.PreDecrementExpression
+unPreDecrementExpression :: Typed.TypedTerm Syntax.PreDecrementExpression -> Typed.TypedTerm Syntax.UnaryExpression
+unPreDecrementExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.PreDecrementExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.PreIncrementExpression
+unPreIncrementExpression :: Typed.TypedTerm Syntax.PreIncrementExpression -> Typed.TypedTerm Syntax.UnaryExpression
+unPreIncrementExpression x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.PreIncrementExpression")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.RecordBody
+unRecordBody :: Typed.TypedTerm Syntax.RecordBody -> Typed.TypedTerm [Syntax.RecordBodyDeclaration]
+unRecordBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.RecordBody")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.RecordComponentModifier
+unRecordComponentModifier :: Typed.TypedTerm Syntax.RecordComponentModifier -> Typed.TypedTerm Syntax.Annotation
+unRecordComponentModifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.RecordComponentModifier")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.RecordHeader
+unRecordHeader :: Typed.TypedTerm Syntax.RecordHeader -> Typed.TypedTerm [Syntax.RecordComponent]
+unRecordHeader x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.RecordHeader")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ResourceSpecification
+unResourceSpecification :: Typed.TypedTerm Syntax.ResourceSpecification -> Typed.TypedTerm [Syntax.Resource]
+unResourceSpecification x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ResourceSpecification")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ReturnStatement
+unReturnStatement :: Typed.TypedTerm Syntax.ReturnStatement -> Typed.TypedTerm (Maybe Syntax.Expression)
+unReturnStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ReturnStatement")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.SimpleTypeName
+unSimpleTypeName :: Typed.TypedTerm Syntax.SimpleTypeName -> Typed.TypedTerm Syntax.TypeIdentifier
+unSimpleTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.SimpleTypeName")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.SingleTypeImportDeclaration
+unSingleTypeImportDeclaration :: Typed.TypedTerm Syntax.SingleTypeImportDeclaration -> Typed.TypedTerm Syntax.TypeName
+unSingleTypeImportDeclaration x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.SingleTypeImportDeclaration")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.StaticImportOnDemandDeclaration
+unStaticImportOnDemandDeclaration :: Typed.TypedTerm Syntax.StaticImportOnDemandDeclaration -> Typed.TypedTerm Syntax.TypeName
+unStaticImportOnDemandDeclaration x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.StaticImportOnDemandDeclaration")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.StaticInitializer
+unStaticInitializer :: Typed.TypedTerm Syntax.StaticInitializer -> Typed.TypedTerm Syntax.Block
+unStaticInitializer x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.StaticInitializer")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.StringLiteral
+unStringLiteral :: Typed.TypedTerm Syntax.StringLiteral -> Typed.TypedTerm String
+unStringLiteral x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.StringLiteral")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.TextBlock
+unTextBlock :: Typed.TypedTerm Syntax.TextBlock -> Typed.TypedTerm String
+unTextBlock x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.TextBlock")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.ThrowStatement
+unThrowStatement :: Typed.TypedTerm Syntax.ThrowStatement -> Typed.TypedTerm Syntax.Expression
+unThrowStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.ThrowStatement")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.Throws
+unThrows :: Typed.TypedTerm Syntax.Throws -> Typed.TypedTerm [Syntax.ExceptionType]
+unThrows x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.Throws")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.TypeIdentifier
+unTypeIdentifier :: Typed.TypedTerm Syntax.TypeIdentifier -> Typed.TypedTerm Syntax.Identifier
+unTypeIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.TypeIdentifier")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.TypeImportOnDemandDeclaration
+unTypeImportOnDemandDeclaration :: Typed.TypedTerm Syntax.TypeImportOnDemandDeclaration -> Typed.TypedTerm Syntax.PackageOrTypeName
+unTypeImportOnDemandDeclaration x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.TypeImportOnDemandDeclaration")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.TypeParameterModifier
+unTypeParameterModifier :: Typed.TypedTerm Syntax.TypeParameterModifier -> Typed.TypedTerm Syntax.Annotation
+unTypeParameterModifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.TypeParameterModifier")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.TypePattern
+unTypePattern :: Typed.TypedTerm Syntax.TypePattern -> Typed.TypedTerm Syntax.LocalVariableDeclaration
+unTypePattern x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.TypePattern")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.UnannClassType
+unUnannClassType :: Typed.TypedTerm Syntax.UnannClassType -> Typed.TypedTerm Syntax.ClassType
+unUnannClassType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.UnannClassType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.UnannType
+unUnannType :: Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.Type
+unUnannType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.UnannType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.java.syntax.YieldStatement
+unYieldStatement :: Typed.TypedTerm Syntax.YieldStatement -> Typed.TypedTerm Syntax.Expression
+unYieldStatement x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.java.syntax.YieldStatement")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.UnannClassType wrapper
+unannClassType :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.UnannClassType
+unannClassType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.UnannClassType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.java.syntax.UnannType wrapper
+unannType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.UnannType
+unannType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.UnannType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the minus variant of hydra.java.syntax.UnaryExpression
+unaryExpressionMinus :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
+unaryExpressionMinus x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "minus"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the cast variant of hydra.java.syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusCast :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusCast x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpressionNotPlusMinus"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "cast"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the not variant of hydra.java.syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusNot :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusNot x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpressionNotPlusMinus"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "not"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the postfix variant of hydra.java.syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusPostfix :: Typed.TypedTerm Syntax.PostfixExpression -> Typed.TypedTerm Syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusPostfix x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpressionNotPlusMinus"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "postfix"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the switchExpression variant of hydra.java.syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusSwitchExpression :: Typed.TypedTerm Syntax.SwitchExpression -> Typed.TypedTerm Syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusSwitchExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpressionNotPlusMinus"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "switchExpression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the tilde variant of hydra.java.syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusTilde :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpressionNotPlusMinus
+unaryExpressionNotPlusMinusTilde x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpressionNotPlusMinus"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "tilde"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the other variant of hydra.java.syntax.UnaryExpression
+unaryExpressionOther :: Typed.TypedTerm Syntax.UnaryExpressionNotPlusMinus -> Typed.TypedTerm Syntax.UnaryExpression
+unaryExpressionOther x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "other"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the plus variant of hydra.java.syntax.UnaryExpression
+unaryExpressionPlus :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
+unaryExpressionPlus x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "plus"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the preDecrement variant of hydra.java.syntax.UnaryExpression
+unaryExpressionPreDecrement :: Typed.TypedTerm Syntax.PreDecrementExpression -> Typed.TypedTerm Syntax.UnaryExpression
+unaryExpressionPreDecrement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "preDecrement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the preIncrement variant of hydra.java.syntax.UnaryExpression
+unaryExpressionPreIncrement :: Typed.TypedTerm Syntax.PreIncrementExpression -> Typed.TypedTerm Syntax.UnaryExpression
+unaryExpressionPreIncrement x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.UnaryExpression"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "preIncrement"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpression :: Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm (Maybe Syntax.ClassBody) -> Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpression typeArguments classOrInterface arguments body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "classOrInterface"),
+          Core.fieldTerm = (Typed.unTypedTerm classOrInterface)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Typed.unTypedTerm arguments)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the arguments field of hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionArguments :: Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm [Syntax.Expression]
+unqualifiedClassInstanceCreationExpressionArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+        Core.projectionFieldName = (Core.Name "arguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionBody :: Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm (Maybe Syntax.ClassBody)
+unqualifiedClassInstanceCreationExpressionBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the classOrInterface field of hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionClassOrInterface :: Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate
+unqualifiedClassInstanceCreationExpressionClassOrInterface x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+        Core.projectionFieldName = (Core.Name "classOrInterface")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typeArguments field of hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionTypeArguments :: Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm [Syntax.TypeArgument]
+unqualifiedClassInstanceCreationExpressionTypeArguments x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+        Core.projectionFieldName = (Core.Name "typeArguments")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the arguments field of hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionWithArguments :: Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionWithArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "classOrInterface"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "classOrInterface")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          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.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the body field of hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionWithBody :: Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm (Maybe Syntax.ClassBody) -> Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "classOrInterface"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "classOrInterface")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the classOrInterface field of hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionWithClassOrInterface :: Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm Syntax.ClassOrInterfaceTypeToInstantiate -> Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionWithClassOrInterface original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "typeArguments")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "classOrInterface"),
+          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.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            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.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typeArguments field of hydra.java.syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionWithTypeArguments :: Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression -> Typed.TypedTerm [Syntax.TypeArgument] -> Typed.TypedTerm Syntax.UnqualifiedClassInstanceCreationExpression
+unqualifiedClassInstanceCreationExpressionWithTypeArguments original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "typeArguments"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "classOrInterface"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "classOrInterface")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "arguments")})),
+            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.java.syntax.UnqualifiedClassInstanceCreationExpression"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the expressionName variant of hydra.java.syntax.VariableAccess
+variableAccessExpressionName :: Typed.TypedTerm Syntax.ExpressionName -> Typed.TypedTerm Syntax.VariableAccess
+variableAccessExpressionName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.VariableAccess"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expressionName"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the fieldAccess variant of hydra.java.syntax.VariableAccess
+variableAccessFieldAccess :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.VariableAccess
+variableAccessFieldAccess x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.VariableAccess"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "fieldAccess"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.java.syntax.VariableArityParameter
+variableArityParameter :: Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableArityParameter
+variableArityParameter modifiers type_ annotations identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.VariableArityParameter
+variableArityParameterAnnotations :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm [Syntax.Annotation]
+variableArityParameterAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.VariableArityParameter
+variableArityParameterIdentifier :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm Syntax.Identifier
+variableArityParameterIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.VariableArityParameter
+variableArityParameterModifiers :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm [Syntax.VariableModifier]
+variableArityParameterModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.VariableArityParameter
+variableArityParameterType :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm Syntax.UnannType
+variableArityParameterType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.VariableArityParameter
+variableArityParameterWithAnnotations :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.VariableArityParameter
+variableArityParameterWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.VariableArityParameter
+variableArityParameterWithIdentifier :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableArityParameter
+variableArityParameterWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.VariableArityParameter
+variableArityParameterWithModifiers :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm [Syntax.VariableModifier] -> Typed.TypedTerm Syntax.VariableArityParameter
+variableArityParameterWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.VariableArityParameter
+variableArityParameterWithType :: Typed.TypedTerm Syntax.VariableArityParameter -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.VariableArityParameter
+variableArityParameterWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityParameter"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponent :: Typed.TypedTerm [Syntax.RecordComponentModifier] -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableArityRecordComponent
+variableArityRecordComponent modifiers type_ annotations identifier =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Typed.unTypedTerm modifiers)},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm type_)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponentAnnotations :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm [Syntax.Annotation]
+variableArityRecordComponentAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponentIdentifier :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm Syntax.Identifier
+variableArityRecordComponentIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the modifiers field of hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponentModifiers :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm [Syntax.RecordComponentModifier]
+variableArityRecordComponentModifiers x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+        Core.projectionFieldName = (Core.Name "modifiers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the type field of hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponentType :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm Syntax.UnannType
+variableArityRecordComponentType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+        Core.projectionFieldName = (Core.Name "type")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponentWithAnnotations :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.VariableArityRecordComponent
+variableArityRecordComponentWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponentWithIdentifier :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableArityRecordComponent
+variableArityRecordComponentWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            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.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the modifiers field of hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponentWithModifiers :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm [Syntax.RecordComponentModifier] -> Typed.TypedTerm Syntax.VariableArityRecordComponent
+variableArityRecordComponentWithModifiers original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          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.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "type")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the type field of hydra.java.syntax.VariableArityRecordComponent
+variableArityRecordComponentWithType :: Typed.TypedTerm Syntax.VariableArityRecordComponent -> Typed.TypedTerm Syntax.UnannType -> Typed.TypedTerm Syntax.VariableArityRecordComponent
+variableArityRecordComponentWithType original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "modifiers"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "modifiers")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "type"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableArityRecordComponent"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.VariableDeclarator
+variableDeclarator :: Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.VariableDeclarator
+variableDeclarator id initializer =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Typed.unTypedTerm id)},
+        Core.Field {
+          Core.fieldName = (Core.Name "initializer"),
+          Core.fieldTerm = (Typed.unTypedTerm initializer)}]}))
+
+-- | DSL accessor for the id field of hydra.java.syntax.VariableDeclarator
+variableDeclaratorId :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm Syntax.VariableDeclaratorId
+variableDeclaratorId x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableDeclarator"),
+        Core.projectionFieldName = (Core.Name "id")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.VariableDeclaratorId
+variableDeclaratorId2 :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.Dims) -> Typed.TypedTerm Syntax.VariableDeclaratorId
+variableDeclaratorId2 identifier dims =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableDeclaratorId"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm identifier)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm dims)}]}))
+
+-- | DSL accessor for the dims field of hydra.java.syntax.VariableDeclaratorId
+variableDeclaratorIdDims :: Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm (Maybe Syntax.Dims)
+variableDeclaratorIdDims x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableDeclaratorId"),
+        Core.projectionFieldName = (Core.Name "dims")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the identifier field of hydra.java.syntax.VariableDeclaratorId
+variableDeclaratorIdIdentifier :: Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.Identifier
+variableDeclaratorIdIdentifier x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableDeclaratorId"),
+        Core.projectionFieldName = (Core.Name "identifier")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the dims field of hydra.java.syntax.VariableDeclaratorId
+variableDeclaratorIdWithDims :: Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm (Maybe Syntax.Dims) -> Typed.TypedTerm Syntax.VariableDeclaratorId
+variableDeclaratorIdWithDims original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableDeclaratorId"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableDeclaratorId"),
+              Core.projectionFieldName = (Core.Name "identifier")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the identifier field of hydra.java.syntax.VariableDeclaratorId
+variableDeclaratorIdWithIdentifier :: Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableDeclaratorId
+variableDeclaratorIdWithIdentifier original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableDeclaratorId"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "identifier"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "dims"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableDeclaratorId"),
+              Core.projectionFieldName = (Core.Name "dims")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL accessor for the initializer field of hydra.java.syntax.VariableDeclarator
+variableDeclaratorInitializer :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm (Maybe Syntax.VariableInitializer)
+variableDeclaratorInitializer x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableDeclarator"),
+        Core.projectionFieldName = (Core.Name "initializer")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the id field of hydra.java.syntax.VariableDeclarator
+variableDeclaratorWithId :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm Syntax.VariableDeclaratorId -> Typed.TypedTerm Syntax.VariableDeclarator
+variableDeclaratorWithId original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "initializer"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableDeclarator"),
+              Core.projectionFieldName = (Core.Name "initializer")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the initializer field of hydra.java.syntax.VariableDeclarator
+variableDeclaratorWithInitializer :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.VariableDeclarator
+variableDeclaratorWithInitializer original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.VariableDeclarator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "id"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.VariableDeclarator"),
+              Core.projectionFieldName = (Core.Name "id")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "initializer"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the arrayInitializer variant of hydra.java.syntax.VariableInitializer
+variableInitializerArrayInitializer :: Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.VariableInitializer
+variableInitializerArrayInitializer x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.VariableInitializer"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "arrayInitializer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the expression variant of hydra.java.syntax.VariableInitializer
+variableInitializerExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.VariableInitializer
+variableInitializerExpression x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.VariableInitializer"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "expression"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the annotation variant of hydra.java.syntax.VariableModifier
+variableModifierAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.VariableModifier
+variableModifierAnnotation x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.VariableModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotation"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the final variant of hydra.java.syntax.VariableModifier
+variableModifierFinal :: Typed.TypedTerm Syntax.VariableModifier
+variableModifierFinal =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.VariableModifier"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "final"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.java.syntax.WhileStatement
+whileStatement :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.WhileStatement
+whileStatement cond body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.WhileStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.WhileStatement
+whileStatementBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Statement
+whileStatementBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.WhileStatement"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.WhileStatement
+whileStatementCond :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm (Maybe Syntax.Expression)
+whileStatementCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.WhileStatement"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.java.syntax.WhileStatementNoShortIf
+whileStatementNoShortIf :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.WhileStatementNoShortIf
+whileStatementNoShortIf cond body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.WhileStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.java.syntax.WhileStatementNoShortIf
+whileStatementNoShortIfBody :: Typed.TypedTerm Syntax.WhileStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf
+whileStatementNoShortIfBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.WhileStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.java.syntax.WhileStatementNoShortIf
+whileStatementNoShortIfCond :: Typed.TypedTerm Syntax.WhileStatementNoShortIf -> Typed.TypedTerm (Maybe Syntax.Expression)
+whileStatementNoShortIfCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.WhileStatementNoShortIf"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.java.syntax.WhileStatementNoShortIf
+whileStatementNoShortIfWithBody :: Typed.TypedTerm Syntax.WhileStatementNoShortIf -> Typed.TypedTerm Syntax.StatementNoShortIf -> Typed.TypedTerm Syntax.WhileStatementNoShortIf
+whileStatementNoShortIfWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.WhileStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.WhileStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.WhileStatementNoShortIf
+whileStatementNoShortIfWithCond :: Typed.TypedTerm Syntax.WhileStatementNoShortIf -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.WhileStatementNoShortIf
+whileStatementNoShortIfWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.WhileStatementNoShortIf"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          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.java.syntax.WhileStatementNoShortIf"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the body field of hydra.java.syntax.WhileStatement
+whileStatementWithBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.WhileStatement
+whileStatementWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.WhileStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.WhileStatement"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the cond field of hydra.java.syntax.WhileStatement
+whileStatementWithCond :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.WhileStatement
+whileStatementWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.WhileStatement"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          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.java.syntax.WhileStatement"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.java.syntax.Wildcard
+wildcard :: Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm (Maybe Syntax.WildcardBounds) -> Typed.TypedTerm Syntax.Wildcard
+wildcard annotations wildcard =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.Wildcard"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm annotations)},
+        Core.Field {
+          Core.fieldName = (Core.Name "wildcard"),
+          Core.fieldTerm = (Typed.unTypedTerm wildcard)}]}))
+
+-- | DSL accessor for the annotations field of hydra.java.syntax.Wildcard
+wildcardAnnotations :: Typed.TypedTerm Syntax.Wildcard -> Typed.TypedTerm [Syntax.Annotation]
+wildcardAnnotations x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Wildcard"),
+        Core.projectionFieldName = (Core.Name "annotations")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the extends variant of hydra.java.syntax.WildcardBounds
+wildcardBoundsExtends :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.WildcardBounds
+wildcardBoundsExtends x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.WildcardBounds"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "extends"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the super variant of hydra.java.syntax.WildcardBounds
+wildcardBoundsSuper :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.WildcardBounds
+wildcardBoundsSuper x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.java.syntax.WildcardBounds"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "super"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL accessor for the wildcard field of hydra.java.syntax.Wildcard
+wildcardWildcard :: Typed.TypedTerm Syntax.Wildcard -> Typed.TypedTerm (Maybe Syntax.WildcardBounds)
+wildcardWildcard x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.java.syntax.Wildcard"),
+        Core.projectionFieldName = (Core.Name "wildcard")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annotations field of hydra.java.syntax.Wildcard
+wildcardWithAnnotations :: Typed.TypedTerm Syntax.Wildcard -> Typed.TypedTerm [Syntax.Annotation] -> Typed.TypedTerm Syntax.Wildcard
+wildcardWithAnnotations original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.Wildcard"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "wildcard"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Wildcard"),
+              Core.projectionFieldName = (Core.Name "wildcard")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the wildcard field of hydra.java.syntax.Wildcard
+wildcardWithWildcard :: Typed.TypedTerm Syntax.Wildcard -> Typed.TypedTerm (Maybe Syntax.WildcardBounds) -> Typed.TypedTerm Syntax.Wildcard
+wildcardWithWildcard original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.java.syntax.Wildcard"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "annotations"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.java.syntax.Wildcard"),
+              Core.projectionFieldName = (Core.Name "annotations")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "wildcard"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.java.syntax.YieldStatement wrapper
+yieldStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.YieldStatement
+yieldStatement x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.java.syntax.YieldStatement"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
diff --git a/src/main/haskell/Hydra/Encode/Gradle.hs b/src/main/haskell/Hydra/Encode/Gradle.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Encode/Gradle.hs
@@ -0,0 +1,49 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Term encoders for hydra.gradle
+
+module Hydra.Encode.Gradle where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.Encode.File as File
+import qualified Hydra.Encode.Packaging as Packaging
+import qualified Hydra.Gradle as Gradle
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+-- | Encoder for hydra.gradle.AntlrConfig
+antlrConfig :: Gradle.AntlrConfig -> Core.Term
+antlrConfig x =
+    Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.gradle.AntlrConfig"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "arguments"),
+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) xs)) (Gradle.antlrConfigArguments x))},
+        Core.Field {
+          Core.fieldName = (Core.Name "outputDirectory"),
+          Core.fieldTerm = (File.filePath (Gradle.antlrConfigOutputDirectory x))}]})
+
+-- | Encoder for hydra.gradle.GradleBuildConfiguration
+gradleBuildConfiguration :: Gradle.GradleBuildConfiguration -> Core.Term
+gradleBuildConfiguration x =
+    Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.gradle.GradleBuildConfiguration"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "dependencies"),
+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.packageDependency xs)) (Gradle.gradleBuildConfigurationDependencies x))},
+        Core.Field {
+          Core.fieldName = (Core.Name "excludes"),
+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) xs)) (Gradle.gradleBuildConfigurationExcludes x))},
+        Core.Field {
+          Core.fieldName = (Core.Name "extraSourceDirs"),
+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map File.filePath xs)) (Gradle.gradleBuildConfigurationExtraSourceDirs x))},
+        Core.Field {
+          Core.fieldName = (Core.Name "plugins"),
+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) xs)) (Gradle.gradleBuildConfigurationPlugins x))},
+        Core.Field {
+          Core.fieldName = (Core.Name "antlr"),
+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map antlrConfig opt)) (Gradle.gradleBuildConfigurationAntlr x))}]})
diff --git a/src/main/haskell/Hydra/Gradle.hs b/src/main/haskell/Hydra/Gradle.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Gradle.hs
@@ -0,0 +1,53 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Build configuration for Gradle-built distribution packages.
+
+module Hydra.Gradle where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.File as File
+import qualified Hydra.Packaging as Packaging
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+-- | Configuration for the Gradle antlr plugin's grammar generation (generateGrammarSource).
+data AntlrConfig =
+  AntlrConfig {
+    -- | Arguments passed to the ANTLR tool, e.g. ["-visitor"] or ["-visitor", "-listener"]. Faithful to ANTLR's command-line interface; covers all ANTLR flags without enumerating them.
+    antlrConfigArguments :: [String],
+    -- | Directory into which ANTLR emits generated lexer/parser sources, relative to the package root (e.g. "build/generated-src/antlr/main"). The host also folds this into the main source set.
+    antlrConfigOutputDirectory :: File.FilePath}
+  deriving (Eq, Ord, Read, Show)
+
+_AntlrConfig = Core.Name "hydra.gradle.AntlrConfig"
+
+_AntlrConfig_arguments = Core.Name "arguments"
+
+_AntlrConfig_outputDirectory = Core.Name "outputDirectory"
+
+-- | The build configuration for a single Gradle-built distribution package, beyond its generated sources.
+data GradleBuildConfiguration =
+  GradleBuildConfiguration {
+    -- | Third-party (non-project) dependencies required by the package. Inter-package dependencies within the project are derived separately and are not listed here. Each dependency's scope (api/runtime/test/tool) is significant; its name carries the Maven group and artifact separated by a colon.
+    gradleBuildConfigurationDependencies :: [Packaging.PackageDependency],
+    -- | Source paths or patterns to exclude from compilation, relative to the package root.
+    gradleBuildConfigurationExcludes :: [String],
+    -- | Additional source directories to fold into the package's main source set, beyond the generated and overlaid sources (e.g. a directory of build-tool-generated sources).
+    gradleBuildConfigurationExtraSourceDirs :: [File.FilePath],
+    -- | Gradle plugin identifiers to apply to the build, e.g. "antlr". Applied in the given order.
+    gradleBuildConfigurationPlugins :: [String],
+    -- | ANTLR grammar-generation configuration, present when the package uses the antlr plugin. When given, the host emits the generateGrammarSource configuration and the compileJava-depends-on-generateGrammarSource ordering. Modeled as structured vocabulary rather than a raw Groovy fragment.
+    gradleBuildConfigurationAntlr :: (Maybe AntlrConfig)}
+  deriving (Eq, Ord, Read, Show)
+
+_GradleBuildConfiguration = Core.Name "hydra.gradle.GradleBuildConfiguration"
+
+_GradleBuildConfiguration_dependencies = Core.Name "dependencies"
+
+_GradleBuildConfiguration_excludes = Core.Name "excludes"
+
+_GradleBuildConfiguration_extraSourceDirs = Core.Name "extraSourceDirs"
+
+_GradleBuildConfiguration_plugins = Core.Name "plugins"
+
+_GradleBuildConfiguration_antlr = Core.Name "antlr"
diff --git a/src/main/haskell/Hydra/Java/Coder.hs b/src/main/haskell/Hydra/Java/Coder.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Java/Coder.hs
@@ -0,0 +1,3200 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Java code generator: converts Hydra modules to Java source code
+
+module Hydra.Java.Coder where
+
+import qualified Hydra.Analysis as Analysis
+import qualified Hydra.Annotations as Annotations
+import qualified Hydra.Arity as Arity
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Checking as Checking
+import qualified Hydra.Classes as Classes
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Constants as Constants
+import qualified Hydra.Core as Core
+import qualified Hydra.Decode.Core as DecodeCore
+import qualified Hydra.Dependencies as Dependencies
+import qualified Hydra.Encode.Core as EncodeCore
+import qualified Hydra.Environment as Environment
+import qualified Hydra.Error.Checking as ErrorChecking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.File as File
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Inference as Inference
+import qualified Hydra.Java.Environment as JavaEnvironment
+import qualified Hydra.Java.Language as Language
+import qualified Hydra.Java.Names as JavaNames
+import qualified Hydra.Java.Serde as Serde
+import qualified Hydra.Java.Syntax as Syntax
+import qualified Hydra.Java.Utils as Utils
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Lexical as Lexical
+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers
+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps
+import qualified Hydra.Overlay.Haskell.Lib.Math as Math
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Names as Names
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Predicates as Predicates
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Resolution as Resolution
+import qualified Hydra.Rewriting as Rewriting
+import qualified Hydra.Scoping as Scoping
+import qualified Hydra.Serialization as Serialization
+import qualified Hydra.Show.Core as ShowCore
+import qualified Hydra.Sorting as Sorting
+import qualified Hydra.Strip as Strip
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variables as Variables
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Map as M
+import qualified Data.Set as S
+
+addComment :: Syntax.ClassBodyDeclaration -> Core.FieldType -> t0 -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclarationWithComments
+addComment decl field cx g =
+    Eithers.map (\c -> Syntax.ClassBodyDeclarationWithComments {
+      Syntax.classBodyDeclarationWithCommentsValue = decl,
+      Syntax.classBodyDeclarationWithCommentsComments = c}) (Annotations.commentsFromFieldType cx g field)
+
+analyzeJavaFunction :: JavaEnvironment.JavaEnvironment -> Core.Term -> Typing.InferenceContext -> t0 -> Either t1 (Typing.FunctionStructure JavaEnvironment.JavaEnvironment)
+analyzeJavaFunction env term cx g = Analysis.analyzeFunctionTerm cx javaEnvGetGraph javaEnvSetGraph env term
+
+annotateBodyWithCod :: Core.Type -> Core.Term -> Core.Term
+annotateBodyWithCod typ term =
+
+      let setAnn = \t -> Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ typ)) t
+      in case (Strip.deannotateTerm term) of
+        Core.TermTypeApplication _ -> setAnn term
+        Core.TermApplication v0 ->
+          let lhs = Core.applicationFunction v0
+              rhs = Core.applicationArgument v0
+              annotatedRhs =
+                      case (Strip.deannotateTerm rhs) of
+                        Core.TermTypeApplication _ -> annotateBodyWithCod (extractArgType lhs typ) rhs
+                        _ -> rhs
+          in (setAnn (Core.TermApplication (Core.Application {
+            Core.applicationFunction = lhs,
+            Core.applicationArgument = annotatedRhs})))
+        _ -> setAnn term
+
+annotateLambdaArgs :: Core.Name -> [Core.Type] -> [Core.Term] -> t0 -> Graph.Graph -> Either t1 [Core.Term]
+annotateLambdaArgs cname tApps argTerms cx g =
+    Logic.ifElse (Lists.null tApps) (Right argTerms) (Eithers.bind (Eithers.bind (Right (Lexical.lookupBinding g cname)) (\mel -> Optionals.cases mel (Right (Optionals.map (\prim -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim))) (Maps.lookup cname (Graph.graphPrimitives g)))) (\el -> Right (Core.bindingTypeScheme el)))) (\mts -> Optionals.cases mts (Right argTerms) (\ts ->
+      let schemeType = Core.typeSchemeBody ts
+          schemeTypeVars = collectTypeVars schemeType
+          schemeVars = Lists.filter (\v -> Sets.member v schemeTypeVars) (Core.typeSchemeVariables ts)
+      in (Logic.ifElse (Logic.or (Lists.null schemeVars) (Logic.not (Equality.equal (Lists.length schemeVars) (Lists.length tApps)))) (Right argTerms) (
+        let subst = Maps.fromList (Lists.zip schemeVars tApps)
+            expectedTypes = peelExpectedTypes subst (Lists.length argTerms) schemeType
+        in (Right (Lists.zipWith (\arg -> \mExpected -> propagateType mExpected arg) argTerms (Lists.concat2 expectedTypes (Lists.replicate (Lists.length argTerms) (Core.TypeVariable (Core.Name "unused")))))))))))
+
+applyCastIfSafe :: JavaEnvironment.Aliases -> Core.Type -> Syntax.Expression -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression
+applyCastIfSafe aliases castType expr cx g =
+
+      let trusted = JavaEnvironment.aliasesTrustedTypeVars aliases
+          inScope = JavaEnvironment.aliasesInScopeTypeParams aliases
+          castVars = collectTypeVars castType
+          javaTypeVars =
+                  Sets.fromList (Lists.filter (\v -> Logic.or (Sets.member v inScope) (isLambdaBoundVariable v)) (Sets.toList castVars))
+          isSafe = Logic.or (Sets.null trusted) (Logic.or (Sets.null javaTypeVars) (Sets.null (Sets.difference javaTypeVars trusted)))
+      in (Logic.ifElse isSafe (Eithers.bind (encodeType aliases Sets.empty castType cx g) (\jtype -> Eithers.bind (Utils.javaTypeToJavaReferenceType jtype cx) (\rt -> Right (Utils.javaCastExpressionToJavaExpression (Utils.javaCastExpression rt (Utils.javaExpressionToJavaUnaryExpression expr)))))) (Right expr))
+
+applyJavaArg :: Syntax.Expression -> Syntax.Expression -> Syntax.Expression
+applyJavaArg expr jarg =
+    Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocation (Just (Right (Utils.javaExpressionToJavaPrimary expr))) (Syntax.Identifier JavaNames.applyMethodName) [
+      jarg])
+
+applyOvergenSubstToTermAnnotations :: M.Map Core.Name Core.Type -> Core.Term -> t0 -> Graph.Graph -> Either t1 Core.Term
+applyOvergenSubstToTermAnnotations subst term0 cx g = Right (applyOvergenSubstToTermAnnotations_go subst g term0)
+
+applyOvergenSubstToTermAnnotations_go :: M.Map Core.Name Core.Type -> Graph.Graph -> Core.Term -> Core.Term
+applyOvergenSubstToTermAnnotations_go subst cx term =
+    case term of
+      Core.TermAnnotated v0 ->
+        let inner = Core.annotatedTermBody v0
+            ann = Annotations.getAnnotationMap (Core.annotatedTermAnnotation v0)
+            ann_ =
+                    Optionals.cases (Maps.lookup Constants.keyType ann) ann (\typeTerm -> Eithers.either (\_ -> ann) (\t ->
+                      let t_ = substituteTypeVarsWithTypes subst t
+                      in (Maps.insert Constants.keyType (EncodeCore.type_ t_) ann)) (DecodeCore.type_ cx typeTerm))
+        in (Core.TermAnnotated (Core.AnnotatedTerm {
+          Core.annotatedTermBody = (applyOvergenSubstToTermAnnotations_go subst cx inner),
+          Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap ann_)}))
+      Core.TermApplication v0 -> Core.TermApplication (Core.Application {
+        Core.applicationFunction = (applyOvergenSubstToTermAnnotations_go subst cx (Core.applicationFunction v0)),
+        Core.applicationArgument = (applyOvergenSubstToTermAnnotations_go subst cx (Core.applicationArgument v0))})
+      Core.TermLambda v0 -> Core.TermLambda (Core.Lambda {
+        Core.lambdaParameter = (Core.lambdaParameter v0),
+        Core.lambdaDomain = (Optionals.map (\d -> substituteTypeVarsWithTypes subst d) (Core.lambdaDomain v0)),
+        Core.lambdaBody = (applyOvergenSubstToTermAnnotations_go subst cx (Core.lambdaBody v0))})
+      Core.TermCases v0 -> Core.TermCases (Core.CaseStatement {
+        Core.caseStatementTypeName = (Core.caseStatementTypeName v0),
+        Core.caseStatementDefault = (Optionals.map (\d -> applyOvergenSubstToTermAnnotations_go subst cx d) (Core.caseStatementDefault v0)),
+        Core.caseStatementCases = (Lists.map (\fld -> Core.CaseAlternative {
+          Core.caseAlternativeName = (Core.caseAlternativeName fld),
+          Core.caseAlternativeHandler = (applyOvergenSubstToTermAnnotations_go subst cx (Core.caseAlternativeHandler fld))}) (Core.caseStatementCases v0))})
+      Core.TermLet v0 -> Core.TermLet (Core.Let {
+        Core.letBindings = (Lists.map (\b -> Core.Binding {
+          Core.bindingName = (Core.bindingName b),
+          Core.bindingTerm = (applyOvergenSubstToTermAnnotations_go subst cx (Core.bindingTerm b)),
+          Core.bindingTypeScheme = (Core.bindingTypeScheme b)}) (Core.letBindings v0)),
+        Core.letBody = (applyOvergenSubstToTermAnnotations_go subst cx (Core.letBody v0))})
+      Core.TermTypeApplication v0 -> Core.TermTypeApplication (Core.TypeApplicationTerm {
+        Core.typeApplicationTermBody = (applyOvergenSubstToTermAnnotations_go subst cx (Core.typeApplicationTermBody v0)),
+        Core.typeApplicationTermType = (substituteTypeVarsWithTypes subst (Core.typeApplicationTermType v0))})
+      Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda {
+        Core.typeLambdaParameter = (Core.typeLambdaParameter v0),
+        Core.typeLambdaBody = (applyOvergenSubstToTermAnnotations_go subst cx (Core.typeLambdaBody v0))})
+      _ -> term
+
+applySubstFull :: M.Map Core.Name Core.Type -> Core.Type -> Core.Type
+applySubstFull s t =
+    case (Strip.deannotateType t) of
+      Core.TypeVariable v0 -> Maps.findWithDefault t v0 s
+      Core.TypeFunction v0 -> Core.TypeFunction (Core.FunctionType {
+        Core.functionTypeDomain = (applySubstFull s (Core.functionTypeDomain v0)),
+        Core.functionTypeCodomain = (applySubstFull s (Core.functionTypeCodomain v0))})
+      Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType {
+        Core.applicationTypeFunction = (applySubstFull s (Core.applicationTypeFunction v0)),
+        Core.applicationTypeArgument = (applySubstFull s (Core.applicationTypeArgument v0))})
+      Core.TypeList v0 -> Core.TypeList (applySubstFull s v0)
+      Core.TypeSet v0 -> Core.TypeSet (applySubstFull s v0)
+      Core.TypeOptional v0 -> Core.TypeOptional (applySubstFull s v0)
+      Core.TypeEffect v0 -> Core.TypeEffect (applySubstFull s v0)
+      Core.TypeMap v0 -> Core.TypeMap (Core.MapType {
+        Core.mapTypeKeys = (applySubstFull s (Core.mapTypeKeys v0)),
+        Core.mapTypeValues = (applySubstFull s (Core.mapTypeValues v0))})
+      Core.TypePair v0 -> Core.TypePair (Core.PairType {
+        Core.pairTypeFirst = (applySubstFull s (Core.pairTypeFirst v0)),
+        Core.pairTypeSecond = (applySubstFull s (Core.pairTypeSecond v0))})
+      Core.TypeEither v0 -> Core.TypeEither (Core.EitherType {
+        Core.eitherTypeLeft = (applySubstFull s (Core.eitherTypeLeft v0)),
+        Core.eitherTypeRight = (applySubstFull s (Core.eitherTypeRight v0))})
+      Core.TypeForall v0 -> Core.TypeForall (Core.ForallType {
+        Core.forallTypeParameter = (Core.forallTypeParameter v0),
+        Core.forallTypeBody = (applySubstFull (Maps.delete (Core.forallTypeParameter v0) s) (Core.forallTypeBody v0))})
+      _ -> t
+
+applySubstSimple :: M.Map Core.Name Core.Type -> Core.Type -> Core.Type
+applySubstSimple subst t =
+    case (Strip.deannotateType t) of
+      Core.TypeVariable v0 -> Maps.findWithDefault t v0 subst
+      _ -> t
+
+arraysCompareExpr :: String -> String -> Syntax.Expression
+arraysCompareExpr otherVar fname =
+
+      let header =
+              Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantType (Utils.javaTypeName (Syntax.Identifier "java.util.Arrays"))),
+                Syntax.methodInvocation_ComplexTypeArguments = [],
+                Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier "compare")})
+          arg1 =
+                  Utils.javaExpressionNameToJavaExpression (Syntax.ExpressionName {
+                    Syntax.expressionNameQualifier = Nothing,
+                    Syntax.expressionNameIdentifier = (Syntax.Identifier (Utils.sanitizeJavaName fname))})
+          arg2 =
+                  Utils.javaExpressionNameToJavaExpression (Utils.fieldExpression (Utils.javaIdentifier otherVar) (Utils.javaIdentifier fname))
+      in (Utils.javaMethodInvocationToJavaExpression (Syntax.MethodInvocation {
+        Syntax.methodInvocationHeader = header,
+        Syntax.methodInvocationArguments = [
+          arg1,
+          arg2]}))
+
+arraysEqualsClause :: String -> String -> Syntax.InclusiveOrExpression
+arraysEqualsClause tmpName fname =
+
+      let thisArg =
+              Utils.javaExpressionNameToJavaExpression (Utils.fieldExpression (Syntax.Identifier "this") (Utils.javaIdentifier fname))
+          otherArg =
+                  Utils.javaExpressionNameToJavaExpression (Utils.fieldExpression (Utils.javaIdentifier tmpName) (Utils.javaIdentifier fname))
+          header =
+                  Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                    Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantType (Utils.javaTypeName (Syntax.Identifier "java.util.Arrays"))),
+                    Syntax.methodInvocation_ComplexTypeArguments = [],
+                    Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier JavaNames.equalsMethodName)})
+      in (Utils.javaPostfixExpressionToJavaInclusiveOrExpression (Utils.javaMethodInvocationToJavaPostfixExpression (Syntax.MethodInvocation {
+        Syntax.methodInvocationHeader = header,
+        Syntax.methodInvocationArguments = [
+          thisArg,
+          otherArg]})))
+
+augmentVariantClass :: JavaEnvironment.Aliases -> [Syntax.TypeParameter] -> Core.Name -> Syntax.ClassDeclaration -> Syntax.ClassDeclaration
+augmentVariantClass aliases tparams elName cd =
+    case cd of
+      Syntax.ClassDeclarationNormal v0 ->
+        let args = Lists.map (\tp -> Utils.typeParameterToTypeArgument tp) tparams
+            extendsPart = Utils.nameToJavaClassType aliases True args elName Nothing
+            newMods =
+                    [
+                      Syntax.ClassModifierPublic,
+                      Syntax.ClassModifierStatic,
+                      Syntax.ClassModifierFinal]
+            oldBody = Syntax.normalClassDeclarationBody v0
+            oldDecls = Syntax.unClassBody oldBody
+            acceptDecl = withCommentString "Dispatch to {@code visitor}." (Utils.toAcceptMethod False tparams)
+            newBody = Syntax.ClassBody (Lists.concat2 oldDecls [
+                  acceptDecl])
+        in (Syntax.ClassDeclarationNormal (Syntax.NormalClassDeclaration {
+          Syntax.normalClassDeclarationModifiers = newMods,
+          Syntax.normalClassDeclarationIdentifier = (Syntax.normalClassDeclarationIdentifier v0),
+          Syntax.normalClassDeclarationParameters = tparams,
+          Syntax.normalClassDeclarationExtends = (Just extendsPart),
+          Syntax.normalClassDeclarationImplements = (Syntax.normalClassDeclarationImplements v0),
+          Syntax.normalClassDeclarationPermits = (Syntax.normalClassDeclarationPermits v0),
+          Syntax.normalClassDeclarationBody = newBody}))
+      _ -> cd
+
+bindingIsFunctionType :: Core.Binding -> Bool
+bindingIsFunctionType b =
+    Optionals.cases (Core.bindingTypeScheme b) (case (Strip.deannotateTerm (Core.bindingTerm b)) of
+      Core.TermLambda _ -> True
+      Core.TermProject _ -> True
+      Core.TermCases _ -> True
+      Core.TermUnwrap _ -> True
+      _ -> False) (\ts -> case (Strip.deannotateType (Core.typeSchemeBody ts)) of
+      Core.TypeFunction _ -> True
+      Core.TypeForall v0 -> case (Strip.deannotateType (Core.forallTypeBody v0)) of
+        Core.TypeFunction _ -> True
+        _ -> False
+      _ -> False)
+
+bindingNameToFilePath :: Core.Name -> String
+bindingNameToFilePath name =
+
+      let qn = Names.qualifyName name
+          ns_ = Util.qualifiedNameModuleName qn
+          local = Util.qualifiedNameLocal qn
+          sanitized = Formatting.sanitizeWithUnderscores Language.reservedWords local
+          unq =
+                  Names.unqualifyName (Util.QualifiedName {
+                    Util.qualifiedNameModuleName = ns_,
+                    Util.qualifiedNameLocal = sanitized})
+      in (Names.nameToFilePath Util.CaseConventionCamel Util.CaseConventionPascal (File.FileExtension "java") unq)
+
+bindingsToStatements :: JavaEnvironment.JavaEnvironment -> [Core.Binding] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error ([Syntax.BlockStatement], JavaEnvironment.JavaEnvironment)
+bindingsToStatements env bindings cx g0 =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+          g = JavaEnvironment.javaEnvironmentGraph env
+          flatBindings = dedupBindings (JavaEnvironment.aliasesInScopeJavaVars aliases) (flattenBindings bindings)
+          gExtended =
+                  Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing) g (Core.Let {
+                    Core.letBindings = flatBindings,
+                    Core.letBody = (Core.TermVariable (Core.Name "dummy"))})
+          bindingVars = Sets.fromList (Lists.map (\b -> Core.bindingName b) flatBindings)
+          allDeps =
+                  Maps.fromList (Lists.map (\b ->
+                    let key = Core.bindingName b
+                        deps = Sets.intersection bindingVars (Variables.freeVariablesInTerm (Core.bindingTerm b))
+                    in (key, deps)) flatBindings)
+          sorted =
+                  Sorting.topologicalSortComponents (Lists.map (\entry ->
+                    let key = Pairs.first entry
+                        deps = Pairs.second entry
+                    in (key, (Sets.toList deps))) (Maps.toList allDeps))
+          recursiveVars =
+                  Sets.fromList (Lists.concat (Lists.map (\names -> Logic.ifElse (Equality.equal (Lists.length names) 1) (Optionals.cases (Lists.maybeHead names) [] (\singleName -> Optionals.cases (Maps.lookup singleName allDeps) [] (\deps -> Logic.ifElse (Sets.member singleName deps) [
+                    singleName] []))) names) sorted))
+          thunkedVars =
+                  Sets.fromList (Lists.concat (Lists.map (\b ->
+                    let bname = Core.bindingName b
+                    in (Logic.ifElse (Logic.and (Logic.not (Sets.member bname recursiveVars)) (Logic.and (Logic.and (Predicates.isComplexBinding g b) (Logic.not (Predicates.isTrivialTerm (Core.bindingTerm b)))) (Logic.not (bindingIsFunctionType b)))) [
+                      bname] [])) flatBindings))
+          aliasesExtended =
+                  JavaEnvironment.Aliases {
+                    JavaEnvironment.aliasesCurrentNamespace = (JavaEnvironment.aliasesCurrentNamespace aliases),
+                    JavaEnvironment.aliasesPackages = (JavaEnvironment.aliasesPackages aliases),
+                    JavaEnvironment.aliasesBranchVars = (JavaEnvironment.aliasesBranchVars aliases),
+                    JavaEnvironment.aliasesRecursiveVars = (Sets.union (JavaEnvironment.aliasesRecursiveVars aliases) recursiveVars),
+                    JavaEnvironment.aliasesInScopeTypeParams = (JavaEnvironment.aliasesInScopeTypeParams aliases),
+                    JavaEnvironment.aliasesPolymorphicLocals = (JavaEnvironment.aliasesPolymorphicLocals aliases),
+                    JavaEnvironment.aliasesInScopeJavaVars = (Sets.union (JavaEnvironment.aliasesInScopeJavaVars aliases) bindingVars),
+                    JavaEnvironment.aliasesVarRenames = (JavaEnvironment.aliasesVarRenames aliases),
+                    JavaEnvironment.aliasesLambdaVars = (JavaEnvironment.aliasesLambdaVars aliases),
+                    JavaEnvironment.aliasesTypeVarSubst = (JavaEnvironment.aliasesTypeVarSubst aliases),
+                    JavaEnvironment.aliasesTrustedTypeVars = (JavaEnvironment.aliasesTrustedTypeVars aliases),
+                    JavaEnvironment.aliasesMethodCodomain = (JavaEnvironment.aliasesMethodCodomain aliases),
+                    JavaEnvironment.aliasesThunkedVars = (Sets.union (JavaEnvironment.aliasesThunkedVars aliases) thunkedVars)}
+          envExtended =
+                  JavaEnvironment.JavaEnvironment {
+                    JavaEnvironment.javaEnvironmentAliases = aliasesExtended,
+                    JavaEnvironment.javaEnvironmentGraph = gExtended}
+      in (Logic.ifElse (Lists.null bindings) (Right ([], envExtended)) (Eithers.bind (Eithers.mapList (\names -> Eithers.bind (Eithers.mapList (\n -> toDeclInit aliasesExtended gExtended recursiveVars flatBindings n cx g) names) (\inits -> Eithers.bind (Eithers.mapList (\n -> toDeclStatement envExtended aliasesExtended gExtended recursiveVars thunkedVars flatBindings n cx g) names) (\decls -> Right (Lists.concat2 (Optionals.cat inits) decls)))) sorted) (\groups -> Right (Lists.concat groups, envExtended))))
+
+boundTypeVariables :: Core.Type -> [Core.Name]
+boundTypeVariables typ =
+    case typ of
+      Core.TypeAnnotated v0 -> boundTypeVariables (Core.annotatedTypeBody v0)
+      Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (boundTypeVariables (Core.forallTypeBody v0))
+      _ -> []
+
+buildArgSubst :: S.Set Core.Name -> [Core.Type] -> [t0] -> M.Map Core.Name t0
+buildArgSubst schemeVarSet schemeDoms argTypes =
+    Maps.fromList (Lists.bind (Lists.zip schemeDoms argTypes) (\p ->
+      let sdom = Pairs.first p
+          argType = Pairs.second p
+      in case (Strip.deannotateType sdom) of
+        Core.TypeVariable v0 -> Logic.ifElse (Sets.member v0 schemeVarSet) [
+          (v0, argType)] []
+        _ -> []))
+
+buildCurriedLambda :: [Core.Name] -> Syntax.Expression -> Syntax.Expression
+buildCurriedLambda params inner = Lists.foldl (\acc -> \p -> Utils.javaLambda p acc) inner (Lists.reverse params)
+
+buildSubstFromAnnotations :: S.Set Core.Name -> Core.Term -> t0 -> Graph.Graph -> Either t1 (M.Map Core.Name Core.Name)
+buildSubstFromAnnotations schemeVarSet term cx g = Right (buildSubstFromAnnotations_go schemeVarSet g term)
+
+buildSubstFromAnnotations_go :: S.Set Core.Name -> Graph.Graph -> Core.Term -> M.Map Core.Name Core.Name
+buildSubstFromAnnotations_go schemeVarSet g term =
+    case term of
+      Core.TermAnnotated v0 ->
+        let body = Core.annotatedTermBody v0
+            anns = Annotations.getAnnotationMap (Core.annotatedTermAnnotation v0)
+            bodySubst = buildSubstFromAnnotations_go schemeVarSet g body
+            annSubst =
+                    Optionals.cases (Maps.lookup Constants.keyType anns) Maps.empty (\typeTerm -> Eithers.either (\_ -> Maps.empty) (\annType -> case (Strip.deannotateTerm body) of
+                      Core.TermLambda v1 -> Optionals.cases (Core.lambdaDomain v1) Maps.empty (\dom -> case (Strip.deannotateType annType) of
+                        Core.TypeFunction v2 -> buildTypeVarSubst schemeVarSet (Core.functionTypeDomain v2) dom
+                        _ -> Maps.empty)
+                      _ -> Maps.empty) (DecodeCore.type_ g typeTerm))
+        in (Maps.union annSubst bodySubst)
+      Core.TermApplication v0 -> Maps.union (buildSubstFromAnnotations_go schemeVarSet g (Core.applicationFunction v0)) (buildSubstFromAnnotations_go schemeVarSet g (Core.applicationArgument v0))
+      Core.TermLambda v0 -> buildSubstFromAnnotations_go schemeVarSet g (Core.lambdaBody v0)
+      Core.TermCases v0 ->
+        let defSubst = Optionals.cases (Core.caseStatementDefault v0) Maps.empty (\d -> buildSubstFromAnnotations_go schemeVarSet g d)
+            caseSubsts =
+                    Lists.foldl (\acc -> \fld -> Maps.union acc (buildSubstFromAnnotations_go schemeVarSet g (Core.caseAlternativeHandler fld))) Maps.empty (Core.caseStatementCases v0)
+        in (Maps.union defSubst caseSubsts)
+      Core.TermLet v0 ->
+        let bindingSubst =
+                Lists.foldl (\acc -> \b -> Maps.union acc (buildSubstFromAnnotations_go schemeVarSet g (Core.bindingTerm b))) Maps.empty (Core.letBindings v0)
+        in (Maps.union bindingSubst (buildSubstFromAnnotations_go schemeVarSet g (Core.letBody v0)))
+      Core.TermList v0 -> Lists.foldl (\acc -> \t -> Maps.union acc (buildSubstFromAnnotations_go schemeVarSet g t)) Maps.empty v0
+      Core.TermOptional v0 -> Optionals.cases v0 Maps.empty (\t -> buildSubstFromAnnotations_go schemeVarSet g t)
+      Core.TermPair v0 -> Maps.union (buildSubstFromAnnotations_go schemeVarSet g (Pairs.first v0)) (buildSubstFromAnnotations_go schemeVarSet g (Pairs.second v0))
+      Core.TermRecord v0 -> Lists.foldl (\acc -> \fld -> Maps.union acc (buildSubstFromAnnotations_go schemeVarSet g (Core.fieldTerm fld))) Maps.empty (Core.recordFields v0)
+      Core.TermSet v0 -> Lists.foldl (\acc -> \t -> Maps.union acc (buildSubstFromAnnotations_go schemeVarSet g t)) Maps.empty (Sets.toList v0)
+      Core.TermTypeApplication v0 -> buildSubstFromAnnotations_go schemeVarSet g (Core.typeApplicationTermBody v0)
+      Core.TermTypeLambda v0 -> buildSubstFromAnnotations_go schemeVarSet g (Core.typeLambdaBody v0)
+      Core.TermEither v0 -> Eithers.either (\t -> buildSubstFromAnnotations_go schemeVarSet g t) (\t -> buildSubstFromAnnotations_go schemeVarSet g t) v0
+      _ -> Maps.empty
+
+buildTypeSubst :: S.Set Core.Name -> Core.Type -> Core.Type -> M.Map Core.Name Core.Type
+buildTypeSubst schemeVarSet schemeType actualType =
+    buildTypeSubst_go schemeVarSet (Strip.deannotateType schemeType) (Strip.deannotateType actualType)
+
+buildTypeSubst_go :: S.Set Core.Name -> Core.Type -> Core.Type -> M.Map Core.Name Core.Type
+buildTypeSubst_go svs st at =
+
+      let goSub = \a -> \b -> buildTypeSubst_go svs (Strip.deannotateType a) (Strip.deannotateType b)
+      in case st of
+        Core.TypeVariable v0 -> Logic.ifElse (Sets.member v0 svs) (Maps.singleton v0 at) Maps.empty
+        Core.TypeFunction v0 -> case at of
+          Core.TypeFunction v1 -> Maps.union (goSub (Core.functionTypeDomain v0) (Core.functionTypeDomain v1)) (goSub (Core.functionTypeCodomain v0) (Core.functionTypeCodomain v1))
+          _ -> Maps.empty
+        Core.TypeApplication v0 -> case at of
+          Core.TypeApplication v1 -> Maps.union (goSub (Core.applicationTypeFunction v0) (Core.applicationTypeFunction v1)) (goSub (Core.applicationTypeArgument v0) (Core.applicationTypeArgument v1))
+          _ -> Maps.empty
+        Core.TypeList v0 -> case at of
+          Core.TypeList v1 -> goSub v0 v1
+          _ -> Maps.empty
+        Core.TypeSet v0 -> case at of
+          Core.TypeSet v1 -> goSub v0 v1
+          _ -> Maps.empty
+        Core.TypeOptional v0 -> case at of
+          Core.TypeOptional v1 -> goSub v0 v1
+          _ -> Maps.empty
+        Core.TypeMap v0 -> case at of
+          Core.TypeMap v1 -> Maps.union (goSub (Core.mapTypeKeys v0) (Core.mapTypeKeys v1)) (goSub (Core.mapTypeValues v0) (Core.mapTypeValues v1))
+          _ -> Maps.empty
+        Core.TypePair v0 -> case at of
+          Core.TypePair v1 -> Maps.union (goSub (Core.pairTypeFirst v0) (Core.pairTypeFirst v1)) (goSub (Core.pairTypeSecond v0) (Core.pairTypeSecond v1))
+          _ -> Maps.empty
+        Core.TypeEither v0 -> case at of
+          Core.TypeEither v1 -> Maps.union (goSub (Core.eitherTypeLeft v0) (Core.eitherTypeLeft v1)) (goSub (Core.eitherTypeRight v0) (Core.eitherTypeRight v1))
+          _ -> Maps.empty
+        Core.TypeForall v0 -> case at of
+          Core.TypeForall v1 -> goSub (Core.forallTypeBody v0) (Core.forallTypeBody v1)
+          _ -> goSub (Core.forallTypeBody v0) at
+        _ -> Maps.empty
+
+buildTypeVarSubst :: S.Set Core.Name -> Core.Type -> Core.Type -> M.Map Core.Name Core.Name
+buildTypeVarSubst schemeVarSet freshTyp canonTyp =
+    buildTypeVarSubst_go schemeVarSet (Strip.deannotateType freshTyp) (Strip.deannotateType canonTyp)
+
+buildTypeVarSubst_go :: S.Set Core.Name -> Core.Type -> Core.Type -> M.Map Core.Name Core.Name
+buildTypeVarSubst_go svs ft ct =
+
+      let goSub = \a -> \b -> buildTypeVarSubst_go svs (Strip.deannotateType a) (Strip.deannotateType b)
+      in case ft of
+        Core.TypeVariable v0 -> case ct of
+          Core.TypeVariable v1 -> Logic.ifElse (Logic.and (Logic.not (Equality.equal v0 v1)) (Sets.member v1 svs)) (Maps.singleton v0 v1) Maps.empty
+          _ -> Maps.empty
+        Core.TypeFunction v0 -> case ct of
+          Core.TypeFunction v1 -> Maps.union (goSub (Core.functionTypeDomain v0) (Core.functionTypeDomain v1)) (goSub (Core.functionTypeCodomain v0) (Core.functionTypeCodomain v1))
+          _ -> Maps.empty
+        Core.TypeApplication v0 -> case ct of
+          Core.TypeApplication v1 -> Maps.union (goSub (Core.applicationTypeFunction v0) (Core.applicationTypeFunction v1)) (goSub (Core.applicationTypeArgument v0) (Core.applicationTypeArgument v1))
+          _ -> Maps.empty
+        Core.TypeList v0 -> case ct of
+          Core.TypeList v1 -> goSub v0 v1
+          _ -> Maps.empty
+        Core.TypeSet v0 -> case ct of
+          Core.TypeSet v1 -> goSub v0 v1
+          _ -> Maps.empty
+        Core.TypeOptional v0 -> case ct of
+          Core.TypeOptional v1 -> goSub v0 v1
+          _ -> Maps.empty
+        Core.TypeMap v0 -> case ct of
+          Core.TypeMap v1 -> Maps.union (goSub (Core.mapTypeKeys v0) (Core.mapTypeKeys v1)) (goSub (Core.mapTypeValues v0) (Core.mapTypeValues v1))
+          _ -> Maps.empty
+        Core.TypePair v0 -> case ct of
+          Core.TypePair v1 -> Maps.union (goSub (Core.pairTypeFirst v0) (Core.pairTypeFirst v1)) (goSub (Core.pairTypeSecond v0) (Core.pairTypeSecond v1))
+          _ -> Maps.empty
+        Core.TypeEither v0 -> case ct of
+          Core.TypeEither v1 -> Maps.union (goSub (Core.eitherTypeLeft v0) (Core.eitherTypeLeft v1)) (goSub (Core.eitherTypeRight v0) (Core.eitherTypeRight v1))
+          _ -> Maps.empty
+        Core.TypeForall v0 -> case ct of
+          Core.TypeForall v1 -> goSub (Core.forallTypeBody v0) (Core.forallTypeBody v1)
+          _ -> buildTypeVarSubst_go svs (Strip.deannotateType (Core.forallTypeBody v0)) ct
+        _ -> case ct of
+          Core.TypeForall v0 -> buildTypeVarSubst_go svs ft (Strip.deannotateType (Core.forallTypeBody v0))
+          _ -> Maps.empty
+
+builderSetterName :: Core.Name -> String
+builderSetterName fname =
+
+      let base = Utils.sanitizeJavaName (Core.unName fname)
+      in (Logic.ifElse (Logic.or (Equality.equal base "build") (Equality.equal base "builder")) (Strings.cat2 base "_") base)
+
+classModsPublic :: [Syntax.ClassModifier]
+classModsPublic = [
+  Syntax.ClassModifierPublic]
+
+classifyDataReference :: Core.Name -> t0 -> Graph.Graph -> Either Errors.Error JavaEnvironment.JavaSymbolClass
+classifyDataReference name cx g =
+    Eithers.bind (Right (Lexical.lookupBinding g name)) (\mel -> Optionals.cases mel (Right JavaEnvironment.JavaSymbolClassLocalVariable) (\el -> Optionals.cases (Core.bindingTypeScheme el) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no type scheme for element " (Core.unName (Core.bindingName el)))))) (\ts -> Right (classifyDataTerm ts (Core.bindingTerm el)))))
+
+classifyDataTerm :: Core.TypeScheme -> Core.Term -> JavaEnvironment.JavaSymbolClass
+classifyDataTerm ts term =
+    Logic.ifElse (Dependencies.isLambda term) (
+      let n = classifyDataTerm_countLambdaParams term
+      in (Logic.ifElse (Equality.gt n 1) (JavaEnvironment.JavaSymbolClassHoistedLambda n) JavaEnvironment.JavaSymbolClassUnaryFunction)) (
+      let hasTypeParams = Logic.not (Lists.null (Core.typeSchemeVariables ts))
+      in (Logic.ifElse hasTypeParams (
+        let n2 = classifyDataTerm_countLambdaParams (classifyDataTerm_stripTypeLambdas term)
+        in (Logic.ifElse (Equality.gt n2 0) (JavaEnvironment.JavaSymbolClassHoistedLambda n2) JavaEnvironment.JavaSymbolClassNullaryFunction)) JavaEnvironment.JavaSymbolClassNullaryFunction))
+
+classifyDataTerm_countLambdaParams :: Core.Term -> Int
+classifyDataTerm_countLambdaParams t =
+    case (Strip.deannotateTerm t) of
+      Core.TermLambda v0 -> Math.add 1 (classifyDataTerm_countLambdaParams (Core.lambdaBody v0))
+      Core.TermLet v0 -> classifyDataTerm_countLambdaParams (Core.letBody v0)
+      _ -> 0
+
+classifyDataTerm_stripTypeLambdas :: Core.Term -> Core.Term
+classifyDataTerm_stripTypeLambdas t =
+    case (Strip.deannotateTerm t) of
+      Core.TermTypeLambda v0 -> classifyDataTerm_stripTypeLambdas (Core.typeLambdaBody v0)
+      _ -> t
+
+cmpDeclStatement :: t0 -> Syntax.BlockStatement
+cmpDeclStatement aliases =
+    Utils.variableDeclarationStatement aliases Utils.javaIntType (Utils.javaIdentifier "cmp") (Utils.javaIntExpression 0)
+
+cmpNotZeroExpr :: Syntax.Expression
+cmpNotZeroExpr =
+    Utils.javaEqualityExpressionToJavaExpression (Syntax.EqualityExpressionNotEqual (Syntax.EqualityExpression_Binary {
+      Syntax.equalityExpression_BinaryLhs = lhs,
+      Syntax.equalityExpression_BinaryRhs = rhs}))
+  where
+    lhs =
+        Utils.javaRelationalExpressionToJavaEqualityExpression (Utils.javaPostfixExpressionToJavaRelationalExpression (Syntax.PostfixExpressionName (Syntax.ExpressionName {
+          Syntax.expressionNameQualifier = Nothing,
+          Syntax.expressionNameIdentifier = (Utils.javaIdentifier "cmp")})))
+    rhs =
+        Utils.javaPostfixExpressionToJavaRelationalExpression (Syntax.PostfixExpressionPrimary (Utils.javaLiteralToJavaPrimary (Utils.javaInt 0)))
+
+collectForallParams :: Core.Type -> [Core.Name]
+collectForallParams t =
+    case (Strip.deannotateType t) of
+      Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (collectForallParams (Core.forallTypeBody v0))
+      _ -> []
+
+collectLambdaDomains :: Core.Term -> ([Core.Type], Core.Term)
+collectLambdaDomains t =
+    case (Strip.deannotateTerm t) of
+      Core.TermLambda v0 -> Optionals.cases (Core.lambdaDomain v0) ([], t) (\dom ->
+        let rest = collectLambdaDomains (Core.lambdaBody v0)
+        in (Lists.cons dom (Pairs.first rest), (Pairs.second rest)))
+      _ -> ([], t)
+
+collectTypeApps :: Core.Term -> [Core.Type] -> (Core.Term, [Core.Type])
+collectTypeApps t acc =
+    case (Strip.deannotateTerm t) of
+      Core.TermTypeApplication v0 -> collectTypeApps (Core.typeApplicationTermBody v0) (Lists.cons (Core.typeApplicationTermType v0) acc)
+      _ -> (Strip.deannotateTerm t, acc)
+
+collectTypeApps0 :: Core.Term -> [Core.Type] -> (Core.Term, [Core.Type])
+collectTypeApps0 t acc =
+    case (Strip.deannotateTerm t) of
+      Core.TermTypeApplication v0 -> collectTypeApps0 (Core.typeApplicationTermBody v0) (Lists.cons (Core.typeApplicationTermType v0) acc)
+      _ -> (t, acc)
+
+collectTypeVars :: Core.Type -> S.Set Core.Name
+collectTypeVars typ = collectTypeVars_go (Strip.deannotateType typ)
+
+collectTypeVars_go :: Core.Type -> S.Set Core.Name
+collectTypeVars_go t =
+    case t of
+      Core.TypeVariable v0 -> Sets.singleton v0
+      Core.TypeFunction v0 -> Sets.union (collectTypeVars_go (Strip.deannotateType (Core.functionTypeDomain v0))) (collectTypeVars_go (Strip.deannotateType (Core.functionTypeCodomain v0)))
+      Core.TypeApplication v0 -> Sets.union (collectTypeVars_go (Strip.deannotateType (Core.applicationTypeFunction v0))) (collectTypeVars_go (Strip.deannotateType (Core.applicationTypeArgument v0)))
+      Core.TypeList v0 -> collectTypeVars_go (Strip.deannotateType v0)
+      Core.TypeSet v0 -> collectTypeVars_go (Strip.deannotateType v0)
+      Core.TypeOptional v0 -> collectTypeVars_go (Strip.deannotateType v0)
+      Core.TypeEffect v0 -> collectTypeVars_go (Strip.deannotateType v0)
+      Core.TypeMap v0 -> Sets.union (collectTypeVars_go (Strip.deannotateType (Core.mapTypeKeys v0))) (collectTypeVars_go (Strip.deannotateType (Core.mapTypeValues v0)))
+      Core.TypePair v0 -> Sets.union (collectTypeVars_go (Strip.deannotateType (Core.pairTypeFirst v0))) (collectTypeVars_go (Strip.deannotateType (Core.pairTypeSecond v0)))
+      Core.TypeEither v0 -> Sets.union (collectTypeVars_go (Strip.deannotateType (Core.eitherTypeLeft v0))) (collectTypeVars_go (Strip.deannotateType (Core.eitherTypeRight v0)))
+      Core.TypeForall v0 -> collectTypeVars_go (Strip.deannotateType (Core.forallTypeBody v0))
+      _ -> Sets.empty
+
+collectionTypeArgs :: String -> Int -> JavaEnvironment.Aliases -> [M.Map Core.Name Core.Term] -> [Syntax.Type] -> t0 -> Graph.Graph -> Either Errors.Error [Syntax.TypeArgument]
+collectionTypeArgs label n aliases anns tyapps cx g =
+    Logic.ifElse (Logic.not (Lists.null tyapps)) (takeTypeArgs label n tyapps cx g) (
+      let combinedAnns = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+      in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnns)) (\mtyp -> Eithers.bind (Optionals.cases mtyp (Right []) (\typ -> case (Strip.deannotateType typ) of
+        Core.TypeList v0 -> Right [
+          v0]
+        Core.TypeSet v0 -> Right [
+          v0]
+        Core.TypeOptional v0 -> Right [
+          v0]
+        Core.TypeMap v0 -> Right [
+          Core.mapTypeKeys v0,
+          (Core.mapTypeValues v0)]
+        _ -> Right [])) (\compTypes -> Eithers.mapList (\ct -> Eithers.bind (encodeType aliases Sets.empty ct cx g) (\jt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jt cx) (\rt -> Right (Syntax.TypeArgumentReference rt)))) compTypes))))
+
+comparableCompareExpr :: String -> String -> Syntax.Expression
+comparableCompareExpr otherVar fname =
+
+      let thisField = Utils.javaIdentifierToJavaExpression (Syntax.Identifier (Utils.sanitizeJavaName fname))
+          otherField =
+                  Utils.javaExpressionNameToJavaExpression (Utils.fieldExpression (Utils.javaIdentifier otherVar) (Utils.javaIdentifier fname))
+      in (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic (Syntax.Identifier "hydra.overlay.java.util.Comparing") (Syntax.Identifier "compare") [
+        thisField,
+        otherField]))
+
+compareAndReturnStmts :: String -> Core.FieldType -> [Syntax.BlockStatement]
+compareAndReturnStmts otherVar f =
+    [
+      Syntax.BlockStatementStatement (Utils.javaAssignmentStatement (Syntax.LeftHandSideExpressionName (Syntax.ExpressionName {
+        Syntax.expressionNameQualifier = Nothing,
+        Syntax.expressionNameIdentifier = (Utils.javaIdentifier "cmp")})) (compareFieldExpr otherVar f)),
+      (Syntax.BlockStatementStatement (Syntax.StatementIfThen (Syntax.IfThenStatement {
+        Syntax.ifThenStatementExpression = cmpNotZeroExpr,
+        Syntax.ifThenStatementStatement = (Utils.javaReturnStatement (Just (Utils.javaExpressionNameToJavaExpression (Syntax.ExpressionName {
+          Syntax.expressionNameQualifier = Nothing,
+          Syntax.expressionNameIdentifier = (Utils.javaIdentifier "cmp")}))))})))]
+
+compareFieldExpr :: String -> Core.FieldType -> Syntax.Expression
+compareFieldExpr otherVar ft =
+
+      let fname = Core.unName (Core.fieldTypeName ft)
+          ftype = Core.fieldTypeType ft
+      in (Logic.ifElse (isBinaryType ftype) (arraysCompareExpr otherVar fname) (Logic.ifElse (isNonComparableType ftype) (hashCodeCompareExpr otherVar fname) (comparableCompareExpr otherVar fname)))
+
+compareToBody :: t0 -> String -> [Core.FieldType] -> [Syntax.BlockStatement]
+compareToBody aliases otherVar fields =
+
+      let zeroStmts = [
+            Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (Utils.javaIntExpression 0)))]
+      in (Optionals.fromOptional zeroStmts (Optionals.map (\p ->
+        let firstField = Pairs.first p
+            restFields = Pairs.second p
+        in (Logic.ifElse (Lists.null restFields) [
+          Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (compareFieldExpr otherVar firstField)))] (Lists.concat2 [
+          cmpDeclStatement aliases] (Lists.concat2 (Lists.concat (Lists.map (\f -> compareAndReturnStmts otherVar f) (Lists.cons firstField (Optionals.fromOptional [] (Lists.maybeInit restFields))))) [
+          Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (compareFieldExpr otherVar (Optionals.fromOptional firstField (Lists.maybeLast restFields)))))])))) (Lists.uncons fields)))
+
+compareToZeroClause :: String -> String -> Syntax.InclusiveOrExpression
+compareToZeroClause tmpName fname =
+
+      let compareToArg =
+              Utils.javaExpressionNameToJavaExpression (Utils.fieldExpression (Utils.javaIdentifier tmpName) (Utils.javaIdentifier fname))
+          compareToVar =
+                  Syntax.MethodInvocation_VariantExpression (Utils.fieldExpression (Syntax.Identifier "this") (Utils.javaIdentifier fname))
+          compareToHeader =
+                  Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                    Syntax.methodInvocation_ComplexVariant = compareToVar,
+                    Syntax.methodInvocation_ComplexTypeArguments = [],
+                    Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier JavaNames.compareToMethodName)})
+          lhs =
+                  Utils.javaRelationalExpressionToJavaEqualityExpression (Utils.javaPostfixExpressionToJavaRelationalExpression (Utils.javaMethodInvocationToJavaPostfixExpression (Syntax.MethodInvocation {
+                    Syntax.methodInvocationHeader = compareToHeader,
+                    Syntax.methodInvocationArguments = [
+                      compareToArg]})))
+          rhs =
+                  Utils.javaPostfixExpressionToJavaRelationalExpression (Syntax.PostfixExpressionPrimary (Utils.javaLiteralToJavaPrimary (Utils.javaInt 0)))
+      in (Utils.javaEqualityExpressionToJavaInclusiveOrExpression (Syntax.EqualityExpressionEqual (Syntax.EqualityExpression_Binary {
+        Syntax.equalityExpression_BinaryLhs = lhs,
+        Syntax.equalityExpression_BinaryRhs = rhs})))
+
+constantDecl :: String -> String -> JavaEnvironment.Aliases -> Core.Name -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclarationWithComments
+constantDecl comment javaName aliases name cx g =
+
+      let mods =
+              [
+                Syntax.FieldModifierPublic,
+                Syntax.FieldModifierStatic,
+                Syntax.FieldModifierFinal]
+          nameName = Utils.nameToJavaName aliases (Core.Name "hydra.core.Name")
+          env =
+                  JavaEnvironment.JavaEnvironment {
+                    JavaEnvironment.javaEnvironmentAliases = aliases,
+                    JavaEnvironment.javaEnvironmentGraph = g}
+      in (Eithers.bind (encodeType aliases Sets.empty (Core.TypeVariable (Core.Name "hydra.core.Name")) cx g) (\jt -> Eithers.bind (encodeTerm env (Core.TermLiteral (Core.LiteralString (Core.unName name))) cx g) (\arg ->
+        let init =
+                Syntax.VariableInitializerExpression (Utils.javaConstructorCall (Utils.javaConstructorName nameName Nothing) [
+                  arg] Nothing)
+            var = Utils.javaVariableDeclarator (Syntax.Identifier javaName) (Just init)
+        in (Right (withCommentString comment (Utils.javaMemberField mods jt var))))))
+
+constantDeclForFieldType :: Core.Name -> JavaEnvironment.Aliases -> Core.FieldType -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclarationWithComments
+constantDeclForFieldType parentName aliases ftyp cx g =
+
+      let name = Core.fieldTypeName ftyp
+          javaName =
+                  Formatting.nonAlnumToUnderscores (Formatting.convertCase Util.CaseConventionCamel Util.CaseConventionUpperSnake (Core.unName name))
+          comment =
+                  Strings.cat [
+                    "Name of the {@code ",
+                    (Core.unName parentName),
+                    ".",
+                    (Core.unName name),
+                    "} field."]
+      in (constantDecl comment javaName aliases name cx g)
+
+constantDeclForTypeName :: JavaEnvironment.Aliases -> Core.Name -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclarationWithComments
+constantDeclForTypeName aliases name cx g =
+
+      let comment =
+              Strings.cat [
+                "Name of the {@code ",
+                (Core.unName name),
+                "} type."]
+      in (constantDecl comment "TYPE_" aliases name cx g)
+
+constructElementsInterface :: Packaging.Module -> [Syntax.InterfaceMemberDeclarationWithComments] -> (Core.Name, Syntax.CompilationUnit)
+constructElementsInterface mod members =
+
+      let ns = Packaging.moduleName mod
+          parentNs = namespaceParent ns
+          pkg = Optionals.cases parentNs (Utils.javaPackageDeclaration ns) (\pns -> Utils.javaPackageDeclaration pns)
+          mods = [
+                Syntax.InterfaceModifierPublic]
+          className = elementsClassName ns
+          elName = elementsQualifiedName ns
+          body = Syntax.InterfaceBody members
+          itf =
+                  Syntax.TopLevelClassOrInterfaceDeclarationInterface (Syntax.InterfaceDeclarationNormalInterface (Syntax.NormalInterfaceDeclaration {
+                    Syntax.normalInterfaceDeclarationModifiers = mods,
+                    Syntax.normalInterfaceDeclarationIdentifier = (Utils.javaTypeIdentifier className),
+                    Syntax.normalInterfaceDeclarationParameters = [],
+                    Syntax.normalInterfaceDeclarationExtends = [],
+                    Syntax.normalInterfaceDeclarationPermits = [],
+                    Syntax.normalInterfaceDeclarationBody = body}))
+          decl =
+                  Syntax.TopLevelClassOrInterfaceDeclarationWithComments {
+                    Syntax.topLevelClassOrInterfaceDeclarationWithCommentsValue = itf,
+                    Syntax.topLevelClassOrInterfaceDeclarationWithCommentsComments = (Optionals.bind (Packaging.moduleMetadata mod) (\em -> Packaging.entityMetadataDescription em))}
+      in (
+        elName,
+        (Syntax.CompilationUnitOrdinary (Syntax.OrdinaryCompilationUnit {
+          Syntax.ordinaryCompilationUnitPackage = (Just pkg),
+          Syntax.ordinaryCompilationUnitImports = [],
+          Syntax.ordinaryCompilationUnitTypes = [
+            decl]})))
+
+correctCastType :: Core.Term -> [Core.Type] -> Core.Type -> t0 -> t1 -> Either t2 Core.Type
+correctCastType innerBody typeArgs fallback cx g =
+    case (Strip.deannotateTerm innerBody) of
+      Core.TermPair _ -> Logic.ifElse (Equality.equal (Lists.length typeArgs) 2) (Right (Core.TypePair (Core.PairType {
+        Core.pairTypeFirst = (Optionals.fromOptional fallback (Lists.maybeAt 0 typeArgs)),
+        Core.pairTypeSecond = (Optionals.fromOptional fallback (Lists.maybeAt 1 typeArgs))}))) (Right fallback)
+      _ -> Right fallback
+
+correctTypeApps :: t0 -> Core.Name -> [Core.Term] -> [Core.Type] -> t1 -> Graph.Graph -> Either Errors.Error [Core.Type]
+correctTypeApps gr name args fallbackTypeApps cx g =
+    Eithers.bind (Right (Lexical.lookupBinding g name)) (\mel -> Optionals.cases mel (Right fallbackTypeApps) (\el -> Optionals.cases (Core.bindingTypeScheme el) (Right fallbackTypeApps) (\ts ->
+      let schemeType = Core.typeSchemeBody ts
+          allSchemeVars = Lists.filter (\v -> isSimpleName v) (Core.typeSchemeVariables ts)
+          schemeTypeVars = collectTypeVars schemeType
+          usedFlags = Lists.map (\v -> Sets.member v schemeTypeVars) allSchemeVars
+          usedSchemeVars = filterByFlags allSchemeVars usedFlags
+          nParams = countFunctionParams schemeType
+          peeled = peelDomainTypes nParams schemeType
+          calleeDoms = Pairs.first peeled
+          calleeCod = Pairs.second peeled
+          overgenSubst = detectAccumulatorUnification calleeDoms calleeCod usedSchemeVars
+          keepFlags =
+                  Lists.map (\v -> Logic.and (Sets.member v schemeTypeVars) (Logic.not (Maps.member v overgenSubst))) allSchemeVars
+          schemeVars = filterByFlags allSchemeVars keepFlags
+          filteredFallback0 =
+                  Logic.ifElse (Equality.equal (Lists.length allSchemeVars) (Lists.length fallbackTypeApps)) (filterByFlags fallbackTypeApps keepFlags) fallbackTypeApps
+          filteredFallback =
+                  Logic.ifElse (Maps.null overgenSubst) filteredFallback0 (Lists.map (\t -> substituteTypeVarsWithTypes overgenSubst t) filteredFallback0)
+      in (Logic.ifElse (Logic.or (Lists.null schemeVars) (Logic.not (Equality.equal (Lists.length schemeVars) (Lists.length filteredFallback)))) (Right filteredFallback) (correctTypeAppsWithArgs schemeVars filteredFallback schemeType args cx g)))))
+
+correctTypeAppsWithArgs :: [Core.Name] -> [Core.Type] -> Core.Type -> [Core.Term] -> t0 -> Graph.Graph -> Either Errors.Error [Core.Type]
+correctTypeAppsWithArgs schemeVars fallbackTypeApps schemeType args cx g =
+
+      let schemeVarSet = Sets.fromList schemeVars
+          irSubst = Maps.fromList (Lists.zip schemeVars fallbackTypeApps)
+          peeled = peelDomainTypes (Lists.length args) schemeType
+          schemeDoms = Pairs.first peeled
+      in (Eithers.bind (Eithers.mapList (\arg -> Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g (Annotations.termAnnotationInternal arg))) args) (\mArgTypes -> Logic.ifElse (Logic.not (Lists.null (Lists.filter (\m -> Optionals.isNone m) mArgTypes))) (Right fallbackTypeApps) (
+        let argTypes = Lists.bind mArgTypes (\m -> Optionals.cases m [] (\x -> Lists.pure x))
+            irDoms = Lists.map (\d -> applySubstSimple irSubst d) schemeDoms
+            domsMatch =
+                    Lists.null (Lists.filter (\p -> Logic.not (typesMatch (Strip.deannotateType (Pairs.first p)) (Strip.deannotateType (Pairs.second p)))) (Lists.zip irDoms argTypes))
+        in (Logic.ifElse domsMatch (Right fallbackTypeApps) (Right (resolveTypeApps schemeVars fallbackTypeApps (buildArgSubst schemeVarSet schemeDoms argTypes)))))))
+
+countFunctionParams :: Core.Type -> Int
+countFunctionParams t =
+    case (Strip.deannotateType t) of
+      Core.TypeFunction v0 -> Math.add 1 (countFunctionParams (Core.functionTypeCodomain v0))
+      _ -> 0
+
+declarationForRecordType :: Bool -> Bool -> JavaEnvironment.Aliases -> [Syntax.TypeParameter] -> Core.Name -> [Core.FieldType] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassDeclaration
+declarationForRecordType isInner isSer aliases tparams elName fields cx g =
+    declarationForRecordType_ isInner isSer aliases tparams elName Nothing fields cx g
+
+declarationForRecordType_ :: Bool -> Bool -> JavaEnvironment.Aliases -> [Syntax.TypeParameter] -> Core.Name -> Maybe Core.Name -> [Core.FieldType] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassDeclaration
+declarationForRecordType_ isInner isSer aliases tparams elName parentName fields cx g =
+    Eithers.bind (Eithers.mapList (\f -> recordMemberVar aliases f cx g) fields) (\memberVars -> Eithers.bind (Eithers.mapList (\p -> addComment (Pairs.first p) (Pairs.second p) cx g) (Lists.zip memberVars fields)) (\memberVars_ ->
+      let elNameStr = Syntax.unIdentifier (Utils.nameToJavaName aliases elName)
+          linkTargetStr =
+                  Optionals.cases parentName elNameStr (\pn -> Strings.cat2 (Strings.cat2 (Syntax.unIdentifier (Utils.nameToJavaName aliases pn)) ".") (Utils.sanitizeJavaName (Util.qualifiedNameLocal (Names.qualifyName elName))))
+      in (Eithers.bind (Logic.ifElse (Equality.gt (Lists.length fields) 1) (Eithers.mapList (\f -> Eithers.bind (recordWithMethod aliases elName fields f cx g) (\decl ->
+        let fname = Core.unName (Core.fieldTypeName f)
+            comment =
+                    Strings.cat [
+                      "Returns a copy of this {@link ",
+                      linkTargetStr,
+                      "} with {@code ",
+                      fname,
+                      "} replaced."]
+        in (Right (withCommentString comment decl)))) fields) (Right [])) (\withMethods -> Eithers.bind (recordConstructor aliases elName fields cx g) (\cons -> Eithers.bind (Eithers.mapList (\f ->
+        let fname = Utils.sanitizeJavaName (Core.unName (Core.fieldTypeName f))
+        in (Eithers.bind (Annotations.commentsFromFieldType cx g f) (\mDoc -> Right (Optionals.cases mDoc "" (\d -> Strings.cat [
+          "@param ",
+          fname,
+          " ",
+          d]))))) fields) (\paramLines ->
+        let nonEmptyParamLines = Lists.filter (\l -> Logic.not (Equality.equal l "")) paramLines
+            consBaseComment =
+                    Strings.cat [
+                      "Constructs an immutable {@link ",
+                      linkTargetStr,
+                      "}."]
+            consComment =
+                    Logic.ifElse (Lists.null nonEmptyParamLines) consBaseComment (Strings.cat [
+                      consBaseComment,
+                      "\n\n",
+                      (Strings.intercalate "\n" nonEmptyParamLines)])
+            consWithComment = withCommentString consComment cons
+        in (Eithers.bind (Logic.ifElse isInner (Right []) (Eithers.bind (constantDeclForTypeName aliases elName cx g) (\d -> Eithers.bind (Eithers.mapList (\f -> constantDeclForFieldType elName aliases f cx g) fields) (\dfields -> Right (Lists.cons d dfields))))) (\tn -> Eithers.bind (Logic.ifElse isInner (Right []) (recordBuilderClass aliases tparams elName fields cx g)) (\builderDecls ->
+          let comparableMethods =
+                  Optionals.cases parentName (Logic.ifElse (Logic.and (Logic.not isInner) isSer) [
+                    recordCompareToMethod aliases tparams elName fields] []) (\pn -> Logic.ifElse isSer [
+                    variantCompareToMethod aliases tparams pn elName fields] [])
+              noCommentMethods =
+                      Lists.map (\x -> noComment x) (Lists.concat2 [
+                        recordEqualsMethod aliases elName fields,
+                        (recordHashCodeMethod fields)] comparableMethods)
+              bodyDecls =
+                      Lists.concat [
+                        tn,
+                        memberVars_,
+                        [
+                          consWithComment],
+                        noCommentMethods,
+                        withMethods,
+                        builderDecls]
+              ifaces = Logic.ifElse isInner (serializableTypes isSer) (interfaceTypes isSer aliases tparams elName)
+          in (Right (Utils.javaClassDeclaration aliases tparams elName classModsPublic Nothing ifaces bodyDecls)))))))))))
+
+declarationForUnionType :: Bool -> JavaEnvironment.Aliases -> [Syntax.TypeParameter] -> Core.Name -> [Core.FieldType] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassDeclaration
+declarationForUnionType isSer aliases tparams elName fields cx g =
+    Eithers.bind (Eithers.mapList (\ft ->
+      let fname = Core.fieldTypeName ft
+          ftype = Core.fieldTypeType ft
+          rfields =
+                  Logic.ifElse (Predicates.isUnitType (Strip.deannotateType ftype)) [] [
+                    Core.FieldType {
+                      Core.fieldTypeName = (Core.Name "value"),
+                      Core.fieldTypeType = (Strip.deannotateType ftype)}]
+          varName = Utils.variantClassName False elName fname
+      in (Eithers.bind (declarationForRecordType_ True isSer aliases [] varName (Logic.ifElse isSer (Just elName) Nothing) rfields cx g) (\innerDecl -> Right (augmentVariantClass aliases tparams elName innerDecl)))) fields) (\variantClasses ->
+      let variantDecls =
+              Lists.map (\vc -> Syntax.ClassBodyDeclarationClassMember (Syntax.ClassMemberDeclarationClass vc)) variantClasses
+      in (Eithers.bind (Eithers.mapList (\pair -> addComment (Pairs.first pair) (Pairs.second pair) cx g) (Lists.zip variantDecls fields)) (\variantDecls_ ->
+        let privateConst = Utils.makeConstructor aliases elName True [] []
+            acceptDecl = Utils.toAcceptMethod True tparams
+            vtparams = Lists.concat2 tparams [
+                  Utils.javaTypeParameter JavaNames.visitorReturnParameter]
+            elNameStr = Syntax.unIdentifier (Utils.nameToJavaName aliases elName)
+            visitorMethods =
+                    Lists.map (\ft ->
+                      let fname = Core.fieldTypeName ft
+                          fnameStr = Core.unName fname
+                          typeArgs = Lists.map (\tp -> Utils.typeParameterToTypeArgument tp) tparams
+                          varName = Utils.variantClassName False elName fname
+                          varNameStr = Syntax.unIdentifier (Utils.nameToJavaName aliases varName)
+                          varLocalStr = Utils.sanitizeJavaName (Util.qualifiedNameLocal (Names.qualifyName varName))
+                          linkVarNameStr = Strings.cat2 (Strings.cat2 elNameStr ".") varLocalStr
+                          varRef = Utils.javaClassTypeToJavaType (Utils.nameToJavaClassType aliases False typeArgs varName Nothing)
+                          param = Utils.javaTypeToJavaFormalParameter varRef (Core.Name "instance")
+                          resultR = Utils.javaTypeToJavaResult (Syntax.TypeReference Utils.visitorTypeVariable)
+                          comment =
+                                  Strings.cat [
+                                    "Visit the {@link ",
+                                    linkVarNameStr,
+                                    "} case."]
+                      in (comment, (Utils.interfaceMethodDeclaration [] [] JavaNames.visitMethodName [
+                        param] resultR Nothing))) fields
+            visitorBody =
+                    Syntax.InterfaceBody (Lists.map (\p -> withInterfaceCommentString (Pairs.first p) (Pairs.second p)) visitorMethods)
+            visitor =
+                    Utils.javaInterfaceDeclarationToJavaClassBodyDeclaration (Syntax.NormalInterfaceDeclaration {
+                      Syntax.normalInterfaceDeclarationModifiers = [
+                        Syntax.InterfaceModifierPublic],
+                      Syntax.normalInterfaceDeclarationIdentifier = (Syntax.TypeIdentifier (Syntax.Identifier JavaNames.visitorName)),
+                      Syntax.normalInterfaceDeclarationParameters = vtparams,
+                      Syntax.normalInterfaceDeclarationExtends = [],
+                      Syntax.normalInterfaceDeclarationPermits = [],
+                      Syntax.normalInterfaceDeclarationBody = visitorBody})
+            typeArgs = Lists.map (\tp -> Utils.typeParameterToTypeArgument tp) tparams
+            visitorClassType =
+                    Utils.javaClassType (Lists.concat2 (Lists.map (\tp -> Utils.typeParameterToReferenceType tp) tparams) [
+                      Utils.visitorTypeVariable]) Nothing JavaNames.visitorName
+            mainInstanceParam =
+                    Utils.javaTypeToJavaFormalParameter (Utils.javaClassTypeToJavaType (Utils.nameToJavaClassType aliases False typeArgs elName Nothing)) (Core.Name "instance")
+            resultR = Utils.javaTypeToJavaResult (Syntax.TypeReference Utils.visitorTypeVariable)
+            throwStmt =
+                    Syntax.BlockStatementStatement (Utils.javaThrowIllegalStateException [
+                      Utils.javaAdditiveExpressionToJavaExpression (Utils.addExpressions [
+                        Utils.javaStringMultiplicativeExpression "Non-exhaustive patterns when matching: ",
+                        (Syntax.MultiplicativeExpressionUnary (Utils.javaIdentifierToJavaUnaryExpression (Syntax.Identifier "instance")))])])
+            defaultMod = [
+                  Syntax.InterfaceMethodModifierDefault]
+            otherwiseDecl =
+                    Utils.interfaceMethodDeclaration defaultMod [] JavaNames.otherwiseMethodName [
+                      mainInstanceParam] resultR (Just [
+                      throwStmt])
+            otherwiseComment = "Default branch for unhandled cases."
+            pvVisitMethods =
+                    Lists.map (\ft ->
+                      let fname = Core.fieldTypeName ft
+                          varName = Utils.variantClassName False elName fname
+                          varNameStr = Syntax.unIdentifier (Utils.nameToJavaName aliases varName)
+                          varLocalStr = Utils.sanitizeJavaName (Util.qualifiedNameLocal (Names.qualifyName varName))
+                          linkVarNameStr = Strings.cat2 (Strings.cat2 elNameStr ".") varLocalStr
+                          varRef = Utils.javaClassTypeToJavaType (Utils.nameToJavaClassType aliases False typeArgs varName Nothing)
+                          param = Utils.javaTypeToJavaFormalParameter varRef (Core.Name "instance")
+                          mi =
+                                  Utils.methodInvocation Nothing (Syntax.Identifier JavaNames.otherwiseMethodName) [
+                                    Utils.javaIdentifierToJavaExpression (Syntax.Identifier "instance")]
+                          returnOtherwise =
+                                  Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (Utils.javaPrimaryToJavaExpression (Utils.javaMethodInvocationToJavaPrimary mi))))
+                          comment =
+                                  Strings.cat [
+                                    "Visit the {@link ",
+                                    linkVarNameStr,
+                                    "} case."]
+                      in (
+                        comment,
+                        (Utils.interfaceMethodDeclaration defaultMod [] JavaNames.visitMethodName [
+                          param] resultR (Just [
+                          returnOtherwise])))) fields
+            pvBody =
+                    Syntax.InterfaceBody (Lists.cons (withInterfaceCommentString otherwiseComment otherwiseDecl) (Lists.map (\p -> withInterfaceCommentString (Pairs.first p) (Pairs.second p)) pvVisitMethods))
+            partialVisitor =
+                    Utils.javaInterfaceDeclarationToJavaClassBodyDeclaration (Syntax.NormalInterfaceDeclaration {
+                      Syntax.normalInterfaceDeclarationModifiers = [
+                        Syntax.InterfaceModifierPublic],
+                      Syntax.normalInterfaceDeclarationIdentifier = (Syntax.TypeIdentifier (Syntax.Identifier JavaNames.partialVisitorName)),
+                      Syntax.normalInterfaceDeclarationParameters = vtparams,
+                      Syntax.normalInterfaceDeclarationExtends = [
+                        Syntax.InterfaceType visitorClassType],
+                      Syntax.normalInterfaceDeclarationPermits = [],
+                      Syntax.normalInterfaceDeclarationBody = pvBody})
+        in (Eithers.bind (constantDeclForTypeName aliases elName cx g) (\tn0 -> Eithers.bind (Eithers.mapList (\ft -> constantDeclForFieldType elName aliases ft cx g) fields) (\tn1 ->
+          let tn = Lists.concat2 [
+                tn0] tn1
+              privateConstComment =
+                      Strings.cat [
+                        "Constructs an immutable {@link ",
+                        elNameStr,
+                        "}."]
+              acceptComment = "Dispatch to {@code visitor}."
+              visitorIfaceComment =
+                      Strings.cat [
+                        "Visitor over {@link ",
+                        elNameStr,
+                        "}."]
+              partialVisitorIfaceComment =
+                      Strings.cat [
+                        "Partial visitor over {@link ",
+                        elNameStr,
+                        "} with a default {@link #otherwise} branch."]
+              otherDecls =
+                      [
+                        withCommentString privateConstComment privateConst,
+                        (withCommentString acceptComment acceptDecl),
+                        (withCommentString visitorIfaceComment visitor),
+                        (withCommentString partialVisitorIfaceComment partialVisitor)]
+              bodyDecls =
+                      Lists.concat [
+                        tn,
+                        otherDecls,
+                        variantDecls_]
+              mods = Lists.concat2 classModsPublic [
+                    Syntax.ClassModifierAbstract]
+          in (Right (Utils.javaClassDeclaration aliases tparams elName mods Nothing (interfaceTypes isSer aliases tparams elName) bodyDecls))))))))
+
+decodeTypeFromTerm :: Core.Term -> Maybe Core.Type
+decodeTypeFromTerm term =
+    case (Strip.deannotateTerm term) of
+      Core.TermInject v0 -> Logic.ifElse (Equality.equal (Core.injectionTypeName v0) (Core.Name "hydra.core.Type")) (
+        let fname = Core.unName (Core.fieldName (Core.injectionField v0))
+            fterm = Core.fieldTerm (Core.injectionField v0)
+        in (Logic.ifElse (Equality.equal fname "variable") (case fterm of
+          Core.TermWrap v1 -> case (Core.wrappedTermBody v1) of
+            Core.TermLiteral v2 -> case v2 of
+              Core.LiteralString v3 -> Just (Core.TypeVariable (Core.Name v3))
+              _ -> Nothing
+            _ -> Nothing
+          _ -> Nothing) (Logic.ifElse (Equality.equal fname "annotated") (case fterm of
+          Core.TermRecord v1 -> Optionals.bind (Lists.maybeHead (Lists.filter (\f -> Equality.equal (Core.fieldName f) (Core.Name "body")) (Core.recordFields v1))) (\bodyField -> decodeTypeFromTerm (Core.fieldTerm bodyField))
+          _ -> Nothing) (Logic.ifElse (Equality.equal fname "application") (case fterm of
+          Core.TermRecord v1 -> Optionals.bind (Lists.maybeHead (Lists.filter (\f -> Equality.equal (Core.fieldName f) (Core.Name "function")) (Core.recordFields v1))) (\funcField -> Optionals.bind (decodeTypeFromTerm (Core.fieldTerm funcField)) (\func -> Optionals.bind (Lists.maybeHead (Lists.filter (\f -> Equality.equal (Core.fieldName f) (Core.Name "argument")) (Core.recordFields v1))) (\argField -> Optionals.map (\arg -> Core.TypeApplication (Core.ApplicationType {
+            Core.applicationTypeFunction = func,
+            Core.applicationTypeArgument = arg})) (decodeTypeFromTerm (Core.fieldTerm argField)))))
+          _ -> Nothing) (Logic.ifElse (Equality.equal fname "function") (case fterm of
+          Core.TermRecord v1 -> Optionals.bind (Lists.maybeHead (Lists.filter (\f -> Equality.equal (Core.fieldName f) (Core.Name "domain")) (Core.recordFields v1))) (\domField -> Optionals.bind (decodeTypeFromTerm (Core.fieldTerm domField)) (\dom -> Optionals.bind (Lists.maybeHead (Lists.filter (\f -> Equality.equal (Core.fieldName f) (Core.Name "codomain")) (Core.recordFields v1))) (\codField -> Optionals.map (\cod -> Core.TypeFunction (Core.FunctionType {
+            Core.functionTypeDomain = dom,
+            Core.functionTypeCodomain = cod})) (decodeTypeFromTerm (Core.fieldTerm codField)))))
+          _ -> Nothing) (Logic.ifElse (Equality.equal fname "literal") (case fterm of
+          Core.TermInject v1 -> Logic.ifElse (Equality.equal (Core.unName (Core.fieldName (Core.injectionField v1))) "string") (Just (Core.TypeLiteral Core.LiteralTypeString)) Nothing
+          _ -> Nothing) Nothing)))))) Nothing
+      _ -> Nothing
+
+dedupBindings :: S.Set Core.Name -> [Core.Binding] -> [Core.Binding]
+dedupBindings inScope bs =
+    Optionals.fromOptional [] (Optionals.map (\p ->
+      let b = Pairs.first p
+          rest = Pairs.second p
+          name = Core.bindingName b
+      in (Logic.ifElse (Sets.member name inScope) (
+        let newName = freshJavaName name inScope
+            subst = Maps.singleton name newName
+            rest2 =
+                    Lists.map (\b2 -> Core.Binding {
+                      Core.bindingName = (Core.bindingName b2),
+                      Core.bindingTerm = (Variables.substituteVariables subst (Core.bindingTerm b2)),
+                      Core.bindingTypeScheme = (Core.bindingTypeScheme b2)}) rest
+        in (Lists.cons (Core.Binding {
+          Core.bindingName = newName,
+          Core.bindingTerm = (Core.bindingTerm b),
+          Core.bindingTypeScheme = (Core.bindingTypeScheme b)}) (dedupBindings (Sets.insert newName inScope) rest2))) (Lists.cons b (dedupBindings (Sets.insert name inScope) rest)))) (Lists.uncons bs))
+
+detectAccumulatorUnification :: [Core.Type] -> Core.Type -> [Core.Name] -> M.Map Core.Name Core.Type
+detectAccumulatorUnification doms cod tparams =
+
+      let tparamSet = Sets.fromList tparams
+          allPairs = Lists.bind doms (\d -> extractInOutPair d)
+          groupedByInput = groupPairsByFirst allPairs
+          selfRefSubst = selfRefSubstitution groupedByInput
+          directPairs = Lists.bind doms (\d -> extractDirectReturn tparamSet d)
+          groupedDirect = groupPairsByFirst directPairs
+          directInputVars = Sets.fromList (Lists.map (\p -> Pairs.first p) directPairs)
+          codVar =
+                  case (Strip.deannotateType cod) of
+                    Core.TypeVariable v0 -> Just v0
+                    _ -> Nothing
+          directRefSubst = directRefSubstitution directInputVars codVar groupedDirect
+          codSubst =
+                  Optionals.cases (findPairFirst cod) Maps.empty (\cv -> Logic.ifElse (Maps.member cv selfRefSubst) Maps.empty (Optionals.cases (findSelfRefVar groupedByInput) Maps.empty (\refVar -> Logic.ifElse (Equality.equal cv refVar) Maps.empty (Maps.singleton cv refVar))))
+          domVars = Sets.fromList (Lists.bind doms (\d -> Sets.toList (collectTypeVars d)))
+          danglingSubst =
+                  Optionals.cases (findPairFirst cod) Maps.empty (\cv -> Logic.ifElse (Sets.member cv domVars) Maps.empty (Optionals.cases (findSelfRefVar groupedByInput) Maps.empty (\refVar -> Maps.singleton cv (Core.TypeVariable refVar))))
+      in (Maps.union (Maps.union (Maps.union (nameMapToTypeMap selfRefSubst) (nameMapToTypeMap codSubst)) danglingSubst) (nameMapToTypeMap directRefSubst))
+
+directRefSubstitution :: (Eq t0, Ord t0) => (S.Set t0 -> Maybe t0 -> M.Map t0 [t0] -> M.Map t0 t0)
+directRefSubstitution directInputVars codVar grouped =
+    Lists.foldl (\subst -> \entry -> directRefSubstitution_processGroup directInputVars codVar subst (Pairs.first entry) (Pairs.second entry)) Maps.empty (Maps.toList grouped)
+
+directRefSubstitution_processGroup :: (Eq t0, Ord t0) => (S.Set t0 -> Maybe t0 -> M.Map t0 t0 -> t0 -> [t0] -> M.Map t0 t0)
+directRefSubstitution_processGroup directInputVars codVar subst inVar outVars =
+
+      let selfRefCount = Lists.length (Lists.filter (\v -> Equality.equal v inVar) outVars)
+          nonSelfVars = Lists.filter (\v -> Logic.not (Equality.equal v inVar)) outVars
+          safeNonSelfVars =
+                  Lists.filter (\v -> Logic.and (Logic.not (Sets.member v directInputVars)) (Logic.not (Equality.equal (Just v) codVar))) nonSelfVars
+      in (Logic.ifElse (Logic.and (Equality.gte selfRefCount 2) (Logic.not (Lists.null safeNonSelfVars))) (Lists.foldl (\s -> \v -> Maps.insert v inVar s) subst safeNonSelfVars) subst)
+
+domTypeArgs :: JavaEnvironment.Aliases -> Core.Type -> t0 -> Graph.Graph -> Either Errors.Error [Syntax.TypeArgument]
+domTypeArgs aliases d cx g =
+
+      let args = extractTypeApplicationArgs (Strip.deannotateType d)
+      in (Logic.ifElse (Logic.not (Lists.null args)) (Eithers.mapList (\t -> Eithers.bind (encodeType aliases Sets.empty t cx g) (\jt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jt cx) (\rt -> Right (Syntax.TypeArgumentReference rt)))) args) (Right (javaTypeArgumentsForType d)))
+
+elementJavaIdentifier :: Bool -> Bool -> JavaEnvironment.Aliases -> Core.Name -> Syntax.Identifier
+elementJavaIdentifier isPrim isMethod aliases name =
+
+      let qn = Names.qualifyName name
+          ns_ = Util.qualifiedNameModuleName qn
+          local = Util.qualifiedNameLocal qn
+          sep = Logic.ifElse isMethod "::" "."
+      in (Logic.ifElse isPrim (Syntax.Identifier (Strings.cat2 (Strings.cat2 (elementJavaIdentifier_qualify aliases ns_ (Formatting.capitalize local)) ".") JavaNames.applyMethodName)) (Optionals.cases ns_ (Syntax.Identifier (Utils.sanitizeJavaName local)) (\n -> Syntax.Identifier (Strings.cat2 (Strings.cat2 (elementJavaIdentifier_qualify aliases (namespaceParent n) (elementsClassName n)) sep) (Utils.sanitizeJavaName local)))))
+
+elementJavaIdentifier_qualify :: JavaEnvironment.Aliases -> Maybe Packaging.ModuleName -> String -> String
+elementJavaIdentifier_qualify aliases mns s =
+    Syntax.unIdentifier (Utils.nameToJavaName aliases (Names.unqualifyName (Util.QualifiedName {
+      Util.qualifiedNameModuleName = mns,
+      Util.qualifiedNameLocal = s})))
+
+elementsClassName :: Packaging.ModuleName -> String
+elementsClassName ns =
+
+      let nsStr = Packaging.unModuleName ns
+          parts = Strings.splitOn "." nsStr
+      in (Formatting.sanitizeWithUnderscores Language.reservedWords (Formatting.capitalize (Optionals.fromOptional nsStr (Lists.maybeLast parts))))
+
+elementsQualifiedName :: Packaging.ModuleName -> Core.Name
+elementsQualifiedName ns =
+    Names.unqualifyName (Util.QualifiedName {
+      Util.qualifiedNameModuleName = (namespaceParent ns),
+      Util.qualifiedNameLocal = (elementsClassName ns)})
+
+encodeApplication :: JavaEnvironment.JavaEnvironment -> Core.Application -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeApplication env app cx g0 =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+          g = JavaEnvironment.javaEnvironmentGraph env
+          gathered = Analysis.gatherArgsWithTypeApps (Core.TermApplication app) [] []
+          fun = Pairs.first gathered
+          args = Pairs.first (Pairs.second gathered)
+          typeApps = Pairs.second (Pairs.second gathered)
+      in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g (Annotations.termAnnotationInternal fun))) (\mfunTyp -> Eithers.bind (Optionals.cases mfunTyp (Checking.typeOfTerm cx g fun) (\t -> Right t)) (\funTyp ->
+        let arity = Arity.typeArity funTyp
+            deannotatedFun = Strip.deannotateTerm fun
+            calleeName =
+                    case deannotatedFun of
+                      Core.TermVariable v0 -> Just v0
+                      _ -> Nothing
+        in (Eithers.bind (Optionals.cases calleeName (Right args) (\cname -> annotateLambdaArgs cname typeApps args cx g)) (\annotatedArgs -> case deannotatedFun of
+          Core.TermVariable v0 -> Logic.ifElse (Optionals.isGiven (Maps.lookup v0 (Graph.graphPrimitives g))) (
+            let hargs = Lists.take arity annotatedArgs
+                rargs = Lists.drop arity annotatedArgs
+            in (Eithers.bind (functionCall env True v0 hargs [] cx g) (\initialCall -> Eithers.foldl (\acc -> \h -> Eithers.bind (encodeTerm env h cx g) (\jarg -> Right (applyJavaArg acc jarg))) initialCall rargs))) (Logic.ifElse (Logic.and (isRecursiveVariable aliases v0) (Logic.not (isLambdaBoundIn v0 (JavaEnvironment.aliasesLambdaVars aliases)))) (encodeApplication_fallback env aliases g typeApps (Core.applicationFunction app) (Core.applicationArgument app) cx g) (Eithers.bind (classifyDataReference v0 cx g) (\symClass ->
+            let methodArity =
+                    case symClass of
+                      JavaEnvironment.JavaSymbolClassHoistedLambda v1 -> v1
+                      _ -> arity
+                hargs = Lists.take methodArity annotatedArgs
+                rargs = Lists.drop methodArity annotatedArgs
+                trusted = JavaEnvironment.aliasesTrustedTypeVars aliases
+                inScope = JavaEnvironment.aliasesInScopeTypeParams aliases
+                filteredTypeApps =
+                        Logic.ifElse (Logic.or (Sets.null trusted) (Sets.null inScope)) [] (
+                          let allVars = Sets.unions (Lists.map (\t -> collectTypeVars t) typeApps)
+                          in (Logic.ifElse (Logic.not (Sets.null (Sets.difference allVars inScope))) [] (Logic.ifElse (Sets.null (Sets.difference allVars trusted)) typeApps [])))
+            in (Eithers.bind (Logic.ifElse (Lists.null filteredTypeApps) (Right []) (correctTypeApps g v0 hargs filteredTypeApps cx g)) (\safeTypeApps -> Eithers.bind (filterPhantomTypeArgs v0 safeTypeApps cx g) (\finalTypeApps -> Eithers.bind (functionCall env False v0 hargs finalTypeApps cx g) (\initialCall -> Eithers.foldl (\acc -> \h -> Eithers.bind (encodeTerm env h cx g) (\jarg -> Right (applyJavaArg acc jarg))) initialCall rargs)))))))
+          _ -> encodeApplication_fallback env aliases g typeApps (Core.applicationFunction app) (Core.applicationArgument app) cx g)))))
+
+encodeApplication_fallback :: JavaEnvironment.JavaEnvironment -> JavaEnvironment.Aliases -> Graph.Graph -> [Core.Type] -> Core.Term -> Core.Term -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeApplication_fallback env aliases gr typeApps lhs rhs cx g =
+    Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g (Annotations.termAnnotationInternal lhs))) (\mt -> Eithers.bind (Optionals.cases mt (Checking.typeOfTerm cx g lhs) (\typ -> Right typ)) (\t -> case (Strip.deannotateTypeParameters (Strip.deannotateType t)) of
+      Core.TypeFunction v0 ->
+        let dom = Core.functionTypeDomain v0
+            cod = Core.functionTypeCodomain v0
+            defaultExpr =
+                    \_bug438_dflt -> Eithers.bind (encodeTerm env lhs cx g) (\jfun -> Eithers.bind (encodeTerm env rhs cx g) (\jarg -> Right (applyJavaArg jfun jarg)))
+            elimBranch =
+                    \_bug438_elim -> Eithers.bind (encodeTerm env rhs cx g) (\jarg -> Eithers.bind (Logic.ifElse (Logic.not (Lists.null (javaTypeArgumentsForType dom))) (Right dom) (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g (Annotations.termAnnotationInternal rhs))) (\mrt -> Optionals.cases mrt (Eithers.bind (Checking.typeOfTerm cx g rhs) (\rt -> Right (Logic.ifElse (Logic.not (Lists.null (javaTypeArgumentsForType rt))) rt dom))) (\rt -> Right (Logic.ifElse (Logic.not (Lists.null (javaTypeArgumentsForType rt))) rt dom))))) (\enrichedDom -> encodeElimination env (Just jarg) enrichedDom cod (Strip.deannotateTerm lhs) cx g))
+        in case (Strip.deannotateAndDetypeTerm lhs) of
+          Core.TermProject _ -> elimBranch ()
+          Core.TermCases _ -> elimBranch ()
+          Core.TermUnwrap _ -> elimBranch ()
+          _ -> defaultExpr ()
+      _ -> Eithers.bind (encodeTerm env lhs cx g) (\jfun -> Eithers.bind (encodeTerm env rhs cx g) (\jarg -> Right (applyJavaArg jfun jarg)))))
+
+encodeDefinitions :: Packaging.Module -> [Packaging.Definition] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error (M.Map Core.Name Syntax.CompilationUnit)
+encodeDefinitions mod defs cx g =
+
+      let aliases = Utils.importAliasesForModule mod
+          env =
+                  JavaEnvironment.JavaEnvironment {
+                    JavaEnvironment.javaEnvironmentAliases = aliases,
+                    JavaEnvironment.javaEnvironmentGraph = g}
+          pkg = Utils.javaPackageDeclaration (Packaging.moduleName mod)
+          partitioned = Environment.partitionDefinitions defs
+          typeDefs = Pairs.first partitioned
+          termDefs = Pairs.second partitioned
+          nonTypedefDefs =
+                  Lists.filter (\td ->
+                    let typ = Core.typeSchemeBody (Packaging.typeDefinitionBody td)
+                    in (isSerializableJavaType typ)) typeDefs
+      in (Eithers.bind (Eithers.mapList (\td -> encodeTypeDefinition pkg aliases td cx g) nonTypedefDefs) (\typeUnits -> Eithers.bind (Logic.ifElse (Lists.null termDefs) (Right []) (Eithers.bind (Eithers.mapList (\td -> encodeTermDefinition env td cx g) termDefs) (\dataMembers -> Right [
+        constructElementsInterface mod dataMembers]))) (\termUnits -> Right (Maps.fromList (Lists.concat2 typeUnits termUnits)))))
+
+encodeElimination :: JavaEnvironment.JavaEnvironment -> Maybe Syntax.Expression -> Core.Type -> Core.Type -> Core.Term -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeElimination env marg dom cod elimTerm cx g =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+      in case (Strip.deannotateAndDetypeTerm elimTerm) of
+        Core.TermProject v0 ->
+          let fname = Core.projectionFieldName v0
+          in (Eithers.bind (encodeType aliases Sets.empty dom cx g) (\jdom0 -> Eithers.bind (Utils.javaTypeToJavaReferenceType jdom0 cx) (\_ -> Optionals.cases marg (
+            let projVar = Core.Name "projected"
+                jbody =
+                        Utils.javaExpressionNameToJavaExpression (Utils.fieldExpression (Utils.variableToJavaIdentifier projVar) (Utils.javaIdentifier (Core.unName fname)))
+            in (Right (Utils.javaLambda projVar jbody))) (\jarg ->
+            let qual = Syntax.FieldAccess_QualifierPrimary (Utils.javaExpressionToJavaPrimary jarg)
+            in (Right (Utils.javaFieldAccessToJavaExpression (Syntax.FieldAccess {
+              Syntax.fieldAccessQualifier = qual,
+              Syntax.fieldAccessIdentifier = (Utils.javaIdentifier (Core.unName fname))})))))))
+        Core.TermCases v0 ->
+          let tname = Core.caseStatementTypeName v0
+              def_ = Core.caseStatementDefault v0
+              fields = Core.caseStatementCases v0
+          in (Optionals.cases marg (
+            let uVar = Core.Name "u"
+                domTypeArgs0 =
+                        \ty -> \acc -> case (Strip.deannotateType ty) of
+                          Core.TypeApplication v1 -> domTypeArgs0 (Core.applicationTypeFunction v1) (Lists.cons (Core.applicationTypeArgument v1) acc)
+                          _ -> acc
+                domTypeArgs = domTypeArgs0 dom []
+                bareElim = Strip.deannotateAndDetypeTerm elimTerm
+                wrappedElimTerm =
+                        Lists.foldl (\trm -> \t -> Core.TermTypeApplication (Core.TypeApplicationTerm {
+                          Core.typeApplicationTermBody = trm,
+                          Core.typeApplicationTermType = t})) bareElim domTypeArgs
+                typedLambda =
+                        Core.TermLambda (Core.Lambda {
+                          Core.lambdaParameter = uVar,
+                          Core.lambdaDomain = (Just dom),
+                          Core.lambdaBody = (Core.TermApplication (Core.Application {
+                            Core.applicationFunction = wrappedElimTerm,
+                            Core.applicationArgument = (Core.TermVariable uVar)}))})
+            in (encodeTerm env typedLambda cx g)) (\jarg ->
+            let prim = Utils.javaExpressionToJavaPrimary jarg
+                consId = innerClassRef aliases tname JavaNames.partialVisitorName
+                effectiveCod = cod
+            in (Eithers.bind (encodeType aliases Sets.empty effectiveCod cx g) (\jcod -> Eithers.bind (Utils.javaTypeToJavaReferenceType jcod cx) (\rt -> Eithers.bind (domTypeArgs aliases dom cx g) (\domArgs ->
+              let targs = typeArgsOrDiamond (Lists.concat2 domArgs [
+                    Syntax.TypeArgumentReference rt])
+              in (Eithers.bind (Optionals.cases def_ (Right []) (\d -> Eithers.bind (otherwiseBranch env aliases dom cod tname jcod domArgs d cx g) (\b -> Right [
+                b]))) (\otherwiseBranches -> Eithers.bind (Eithers.mapList (\f -> visitBranch env aliases dom tname jcod domArgs f cx g) fields) (\visitBranches ->
+                let body = Syntax.ClassBody (Lists.concat2 otherwiseBranches visitBranches)
+                    visitor = Utils.javaConstructorCall (Utils.javaConstructorName consId (Just targs)) [] (Just body)
+                in (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocation (Just (Right prim)) (Syntax.Identifier JavaNames.acceptMethodName) [
+                  visitor]))))))))))))
+        Core.TermUnwrap _ ->
+          let withArg =
+                  \ja -> Utils.javaFieldAccessToJavaExpression (Syntax.FieldAccess {
+                    Syntax.fieldAccessQualifier = (Syntax.FieldAccess_QualifierPrimary (Utils.javaExpressionToJavaPrimary ja)),
+                    Syntax.fieldAccessIdentifier = (Utils.javaIdentifier JavaNames.valueFieldName)})
+          in (Right (Optionals.cases marg (
+            let wVar = Core.Name "wrapped"
+                wArg = Utils.javaIdentifierToJavaExpression (Utils.variableToJavaIdentifier wVar)
+            in (Utils.javaLambda wVar (withArg wArg))) (\jarg -> withArg jarg)))
+        _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "unexpected " (Strings.cat2 "elimination case" (Strings.cat2 " in " "encodeElimination")))))
+
+encodeFunction :: JavaEnvironment.JavaEnvironment -> Core.Type -> Core.Type -> Core.Term -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeFunction env dom cod funTerm cx g =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+          encodeLambdaFallback =
+                  \env2 -> \lam ->
+                    let lambdaVar = Core.lambdaParameter lam
+                        body = Core.lambdaBody lam
+                    in (Eithers.bind (analyzeJavaFunction env2 body cx g) (\fs ->
+                      let bindings = Typing.functionStructureBindings fs
+                          innerBody = Typing.functionStructureBody fs
+                          env3 = Typing.functionStructureEnvironment fs
+                      in (Eithers.bind (bindingsToStatements env3 bindings cx g) (\bindResult ->
+                        let bindingStmts = Pairs.first bindResult
+                            env4 = Pairs.second bindResult
+                        in (Eithers.bind (encodeTerm env4 innerBody cx g) (\jbody ->
+                          let lam1 =
+                                  Logic.ifElse (Lists.null bindings) (Utils.javaLambda lambdaVar jbody) (
+                                    let returnSt = Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just jbody))
+                                    in (Utils.javaLambdaFromBlock lambdaVar (Syntax.Block (Lists.concat2 bindingStmts [
+                                      returnSt]))))
+                          in (applyCastIfSafe aliases (Core.TypeFunction (Core.FunctionType {
+                            Core.functionTypeDomain = dom,
+                            Core.functionTypeCodomain = cod})) lam1 cx g)))))))
+      in case (Strip.deannotateTerm funTerm) of
+        Core.TermProject _ -> encodeElimination env Nothing dom cod (Strip.deannotateTerm funTerm) cx g
+        Core.TermCases _ -> encodeElimination env Nothing dom cod (Strip.deannotateTerm funTerm) cx g
+        Core.TermUnwrap _ -> encodeElimination env Nothing dom cod (Strip.deannotateTerm funTerm) cx g
+        Core.TermLambda v0 -> withLambda env v0 (\env2 ->
+          let lambdaVar = Core.lambdaParameter v0
+              body = Core.lambdaBody v0
+          in case (Strip.deannotateTerm body) of
+            Core.TermLambda v1 -> case (Strip.deannotateType cod) of
+              Core.TypeFunction v2 ->
+                let dom2 = Core.functionTypeDomain v2
+                    cod2 = Core.functionTypeCodomain v2
+                in (Eithers.bind (encodeFunction env2 dom2 cod2 (Core.TermLambda v1) cx g) (\innerJavaLambda ->
+                  let lam1 = Utils.javaLambda lambdaVar innerJavaLambda
+                  in (applyCastIfSafe aliases (Core.TypeFunction (Core.FunctionType {
+                    Core.functionTypeDomain = dom,
+                    Core.functionTypeCodomain = cod})) lam1 cx g)))
+              _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "expected function type for lambda body, but got: " (ShowCore.type_ cod))))
+            _ -> encodeLambdaFallback env2 v0)
+        _ -> Right (encodeLiteral (Core.LiteralString (Strings.cat2 "Unimplemented function variant: " (ShowCore.term funTerm))))
+
+encodeFunctionFormTerm :: JavaEnvironment.JavaEnvironment -> [M.Map Core.Name Core.Term] -> Core.Term -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeFunctionFormTerm env anns term cx g =
+
+      let combinedAnns = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+      in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnns)) (\mt -> Eithers.bind (Optionals.cases mt (Optionals.cases (tryInferFunctionType term) (Checking.typeOfTerm cx g term) (\inferredType -> Right inferredType)) (\t -> Right t)) (\typ -> case (Strip.deannotateType typ) of
+        Core.TypeFunction v0 -> encodeFunction env (Core.functionTypeDomain v0) (Core.functionTypeCodomain v0) term cx g
+        _ -> encodeNullaryConstant env typ term cx g)))
+
+encodeFunctionPrimitiveByName :: JavaEnvironment.JavaEnvironment -> Core.Type -> Core.Type -> Core.Name -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeFunctionPrimitiveByName env dom cod name cx g =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+          classWithApply = Syntax.unIdentifier (elementJavaIdentifier True False aliases name)
+          suffix = Strings.cat2 "." JavaNames.applyMethodName
+          className =
+                  Strings.fromList (Lists.take (Math.sub (Strings.length classWithApply) (Strings.length suffix)) (Strings.toList classWithApply))
+          arity =
+                  Arity.typeArity (Core.TypeFunction (Core.FunctionType {
+                    Core.functionTypeDomain = dom,
+                    Core.functionTypeCodomain = cod}))
+      in (Logic.ifElse (Equality.lte arity 1) (Right (Utils.javaIdentifierToJavaExpression (Syntax.Identifier (Strings.cat [
+        className,
+        "::",
+        JavaNames.applyMethodName])))) (
+        let paramNames = Lists.map (\i -> Core.Name (Strings.cat2 "p" (Literals.showInt32 i))) (Math.range 0 (Math.sub arity 1))
+            paramExprs = Lists.map (\p -> Utils.javaIdentifierToJavaExpression (Utils.variableToJavaIdentifier p)) paramNames
+            classId = Syntax.Identifier className
+            call =
+                    Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic classId (Syntax.Identifier JavaNames.applyMethodName) paramExprs)
+            curried = buildCurriedLambda paramNames call
+        in (Eithers.bind (encodeType aliases Sets.empty (Core.TypeFunction (Core.FunctionType {
+          Core.functionTypeDomain = dom,
+          Core.functionTypeCodomain = cod})) cx g) (\jtype -> Eithers.bind (Utils.javaTypeToJavaReferenceType jtype cx) (\rt -> Right (Utils.javaCastExpressionToJavaExpression (Utils.javaCastExpression rt (Utils.javaExpressionToJavaUnaryExpression curried))))))))
+
+encodeLiteral :: Core.Literal -> Syntax.Expression
+encodeLiteral lit =
+    case lit of
+      Core.LiteralBinary v0 ->
+        let byteValues = Literals.binaryToBytes v0
+        in (Utils.javaArrayCreation Utils.javaBytePrimitiveType (Just (Utils.javaArrayInitializer (Lists.map (\w -> Utils.javaLiteralToJavaExpression (Syntax.LiteralInteger (Syntax.IntegerLiteral (Literals.int32ToBigint w)))) byteValues))))
+      Core.LiteralBoolean v0 -> encodeLiteral_litExp (Utils.javaBoolean v0)
+      Core.LiteralDecimal v0 -> Utils.javaConstructorCall (Utils.javaConstructorName (Syntax.Identifier "java.math.BigDecimal") Nothing) [
+        encodeLiteral (Core.LiteralString (Literals.showDecimal v0))] Nothing
+      Core.LiteralFloat v0 -> encodeLiteral_encodeFloat v0
+      Core.LiteralInteger v0 -> encodeLiteral_encodeInteger v0
+      Core.LiteralString v0 -> encodeLiteral_litExp (Utils.javaString v0)
+
+encodeLiteralType :: Core.LiteralType -> t0 -> t1 -> Either t2 Syntax.Type
+encodeLiteralType lt cx g =
+    case lt of
+      Core.LiteralTypeBinary -> Right (Syntax.TypeReference (Syntax.ReferenceTypeArray (Syntax.ArrayType {
+        Syntax.arrayTypeDims = (Syntax.Dims [
+          []]),
+        Syntax.arrayTypeVariant = (Syntax.ArrayType_VariantPrimitive (Syntax.PrimitiveTypeWithAnnotations {
+          Syntax.primitiveTypeWithAnnotationsType = (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeIntegral Syntax.IntegralTypeByte)),
+          Syntax.primitiveTypeWithAnnotationsAnnotations = []}))})))
+      Core.LiteralTypeBoolean -> encodeLiteralType_simple "Boolean" cx g
+      Core.LiteralTypeDecimal -> Right (Utils.javaRefType [] (Just (JavaNames.javaPackageName [
+        "java",
+        "math"])) "BigDecimal")
+      Core.LiteralTypeFloat v0 -> case v0 of
+        Core.FloatTypeFloat32 -> encodeLiteralType_simple "Float" cx g
+        Core.FloatTypeFloat64 -> encodeLiteralType_simple "Double" cx g
+      Core.LiteralTypeInteger v0 -> case v0 of
+        Core.IntegerTypeBigint -> Right (Utils.javaRefType [] (Just (JavaNames.javaPackageName [
+          "java",
+          "math"])) "BigInteger")
+        Core.IntegerTypeInt8 -> encodeLiteralType_simple "Byte" cx g
+        Core.IntegerTypeInt16 -> encodeLiteralType_simple "Short" cx g
+        Core.IntegerTypeInt32 -> encodeLiteralType_simple "Integer" cx g
+        Core.IntegerTypeInt64 -> encodeLiteralType_simple "Long" cx g
+        Core.IntegerTypeUint8 -> encodeLiteralType_simple "Short" cx g
+        Core.IntegerTypeUint16 -> encodeLiteralType_simple "Character" cx g
+        Core.IntegerTypeUint32 -> encodeLiteralType_simple "Long" cx g
+        Core.IntegerTypeUint64 -> Right (Utils.javaRefType [] (Just (JavaNames.javaPackageName [
+          "java",
+          "math"])) "BigInteger")
+      Core.LiteralTypeString -> encodeLiteralType_simple "String" cx g
+
+encodeLiteralType_simple :: String -> t0 -> t1 -> Either t2 Syntax.Type
+encodeLiteralType_simple n cx g = Right (Utils.javaRefType [] Nothing n)
+
+encodeLiteral_encodeFloat :: Core.FloatValue -> Syntax.Expression
+encodeLiteral_encodeFloat f =
+    case f of
+      Core.FloatValueFloat32 v0 -> encodeLiteral_encodeFloat32 v0
+      Core.FloatValueFloat64 v0 -> encodeLiteral_encodeFloat64 v0
+
+encodeLiteral_encodeFloat32 :: Float -> Syntax.Expression
+encodeLiteral_encodeFloat32 v =
+
+      let s = Literals.showFloat32 v
+      in (Logic.ifElse (Equality.equal s "NaN") (encodeLiteral_javaSpecialFloatExpr "Float" "NaN") (Logic.ifElse (Equality.equal s "Infinity") (encodeLiteral_javaSpecialFloatExpr "Float" "POSITIVE_INFINITY") (Logic.ifElse (Equality.equal s "-Infinity") (encodeLiteral_javaSpecialFloatExpr "Float" "NEGATIVE_INFINITY") (encodeLiteral_primCast (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeFloatingPoint Syntax.FloatingPointTypeFloat)) (encodeLiteral_litExp (Syntax.LiteralFloatingPoint (Syntax.FloatingPointLiteral (Literals.float32ToFloat64 v))))))))
+
+encodeLiteral_encodeFloat64 :: Double -> Syntax.Expression
+encodeLiteral_encodeFloat64 v =
+
+      let s = Literals.showFloat64 v
+      in (Logic.ifElse (Equality.equal s "NaN") (encodeLiteral_javaSpecialFloatExpr "Double" "NaN") (Logic.ifElse (Equality.equal s "Infinity") (encodeLiteral_javaSpecialFloatExpr "Double" "POSITIVE_INFINITY") (Logic.ifElse (Equality.equal s "-Infinity") (encodeLiteral_javaSpecialFloatExpr "Double" "NEGATIVE_INFINITY") (Logic.ifElse (Equality.equal s "-0.0") (encodeLiteral_javaParseDouble "-0.0") (encodeLiteral_litExp (Syntax.LiteralFloatingPoint (Syntax.FloatingPointLiteral v)))))))
+
+encodeLiteral_encodeInteger :: Core.IntegerValue -> Syntax.Expression
+encodeLiteral_encodeInteger i =
+    case i of
+      Core.IntegerValueBigint v0 -> Utils.javaConstructorCall (Utils.javaConstructorName (Syntax.Identifier "java.math.BigInteger") Nothing) [
+        encodeLiteral (Core.LiteralString (Literals.showBigint v0))] Nothing
+      Core.IntegerValueInt8 v0 -> encodeLiteral_primCast (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeIntegral Syntax.IntegralTypeByte)) (encodeLiteral_litExp (Syntax.LiteralInteger (Syntax.IntegerLiteral (Literals.int8ToBigint v0))))
+      Core.IntegerValueInt16 v0 -> encodeLiteral_primCast (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeIntegral Syntax.IntegralTypeShort)) (encodeLiteral_litExp (Syntax.LiteralInteger (Syntax.IntegerLiteral (Literals.int16ToBigint v0))))
+      Core.IntegerValueInt32 v0 -> encodeLiteral_litExp (Syntax.LiteralInteger (Syntax.IntegerLiteral (Literals.int32ToBigint v0)))
+      Core.IntegerValueInt64 v0 -> encodeLiteral_primCast (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeIntegral Syntax.IntegralTypeLong)) (encodeLiteral_litExp (Syntax.LiteralInteger (Syntax.IntegerLiteral (Literals.int64ToBigint v0))))
+      Core.IntegerValueUint8 v0 -> encodeLiteral_primCast (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeIntegral Syntax.IntegralTypeShort)) (encodeLiteral_litExp (Syntax.LiteralInteger (Syntax.IntegerLiteral (Literals.uint8ToBigint v0))))
+      Core.IntegerValueUint16 v0 -> encodeLiteral_litExp (Syntax.LiteralCharacter v0)
+      Core.IntegerValueUint32 v0 -> encodeLiteral_primCast (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeIntegral Syntax.IntegralTypeLong)) (encodeLiteral_litExp (Syntax.LiteralInteger (Syntax.IntegerLiteral (Literals.uint32ToBigint v0))))
+      Core.IntegerValueUint64 v0 -> Utils.javaConstructorCall (Utils.javaConstructorName (Syntax.Identifier "java.math.BigInteger") Nothing) [
+        encodeLiteral (Core.LiteralString (Literals.showBigint (Literals.uint64ToBigint v0)))] Nothing
+
+encodeLiteral_javaParseDouble :: String -> Syntax.Expression
+encodeLiteral_javaParseDouble value =
+    Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic (Syntax.Identifier "Double") (Syntax.Identifier "parseDouble") [
+      encodeLiteral (Core.LiteralString value)])
+
+encodeLiteral_javaSpecialFloatExpr :: String -> String -> Syntax.Expression
+encodeLiteral_javaSpecialFloatExpr className fieldName =
+    Utils.javaExpressionNameToJavaExpression (Syntax.ExpressionName {
+      Syntax.expressionNameQualifier = (Just (Syntax.AmbiguousName [
+        Syntax.Identifier className])),
+      Syntax.expressionNameIdentifier = (Syntax.Identifier fieldName)})
+
+encodeLiteral_litExp :: Syntax.Literal -> Syntax.Expression
+encodeLiteral_litExp l = Utils.javaLiteralToJavaExpression l
+
+encodeLiteral_primCast :: Syntax.PrimitiveType -> Syntax.Expression -> Syntax.Expression
+encodeLiteral_primCast pt expr =
+    Utils.javaCastExpressionToJavaExpression (Utils.javaCastPrimitive pt (Utils.javaExpressionToJavaUnaryExpression expr))
+
+encodeNullaryConstant :: t0 -> t1 -> Core.Term -> t2 -> t3 -> Either Errors.Error t4
+encodeNullaryConstant env typ funTerm cx g =
+    Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "unexpected " (Strings.cat2 "nullary function" (Strings.cat2 " in " (ShowCore.term funTerm))))))
+
+encodeNullaryConstant_typeArgsFromReturnType :: JavaEnvironment.Aliases -> Core.Type -> t0 -> Graph.Graph -> Either Errors.Error [Syntax.TypeArgument]
+encodeNullaryConstant_typeArgsFromReturnType aliases t cx g =
+    case (Strip.deannotateType t) of
+      Core.TypeSet v0 -> Eithers.bind (encodeType aliases Sets.empty v0 cx g) (\jst -> Eithers.bind (Utils.javaTypeToJavaReferenceType jst cx) (\rt -> Right [
+        Syntax.TypeArgumentReference rt]))
+      Core.TypeList v0 -> Eithers.bind (encodeType aliases Sets.empty v0 cx g) (\jlt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jlt cx) (\rt -> Right [
+        Syntax.TypeArgumentReference rt]))
+      Core.TypeOptional v0 -> Eithers.bind (encodeType aliases Sets.empty v0 cx g) (\jmt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jmt cx) (\rt -> Right [
+        Syntax.TypeArgumentReference rt]))
+      Core.TypeMap v0 -> Eithers.bind (encodeType aliases Sets.empty (Core.mapTypeKeys v0) cx g) (\jkt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jkt cx) (\rk -> Eithers.bind (encodeType aliases Sets.empty (Core.mapTypeValues v0) cx g) (\jvt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jvt cx) (\rv -> Right [
+        Syntax.TypeArgumentReference rk,
+        (Syntax.TypeArgumentReference rv)]))))
+      _ -> Right []
+
+encodeNullaryPrimitiveByName :: JavaEnvironment.JavaEnvironment -> Core.Type -> Core.Name -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeNullaryPrimitiveByName env typ name cx g =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+      in (Eithers.bind (encodeNullaryConstant_typeArgsFromReturnType aliases typ cx g) (\targs -> Logic.ifElse (Lists.null targs) (
+        let header = Syntax.MethodInvocation_HeaderSimple (Syntax.MethodName (elementJavaIdentifier True False aliases name))
+        in (Right (Utils.javaMethodInvocationToJavaExpression (Syntax.MethodInvocation {
+          Syntax.methodInvocationHeader = header,
+          Syntax.methodInvocationArguments = []})))) (
+        let fullName = Syntax.unIdentifier (elementJavaIdentifier True False aliases name)
+            parts = Strings.splitOn "." fullName
+            className = Syntax.Identifier (Strings.intercalate "." (Optionals.fromOptional [] (Lists.maybeInit parts)))
+            methodName = Syntax.Identifier (Optionals.fromOptional fullName (Lists.maybeLast parts))
+        in (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs className methodName targs []))))))
+
+encodeTerm :: JavaEnvironment.JavaEnvironment -> Core.Term -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeTerm env term cx g = encodeTermInternal env [] [] term cx g
+
+encodeTermDefinition :: JavaEnvironment.JavaEnvironment -> Packaging.TermDefinition -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.InterfaceMemberDeclarationWithComments
+encodeTermDefinition env tdef cx g =
+
+      let name = Packaging.termDefinitionName tdef
+          term0 = Packaging.termDefinitionBody tdef
+      in (Eithers.bind (Annotations.getTermDescription cx g term0) (\mDoc ->
+        let ts =
+                Optionals.cases (Packaging.termDefinitionSignature tdef) (Core.TypeScheme {
+                  Core.typeSchemeVariables = [],
+                  Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Unit")),
+                  Core.typeSchemeConstraints = Nothing}) (\sig -> Scoping.termSignatureToTypeScheme sig)
+            term = Variables.unshadowVariables term0
+        in (Eithers.bind (analyzeJavaFunction env term cx g) (\fs ->
+          let schemeVars = Lists.filter (\v -> isSimpleName v) (Core.typeSchemeVariables ts)
+              termVars = Typing.functionStructureTypeParams fs
+              schemeTypeVars = collectTypeVars (Core.typeSchemeBody ts)
+              usedSchemeVars = Lists.filter (\v -> Sets.member v schemeTypeVars) schemeVars
+              tparams = Logic.ifElse (Lists.null usedSchemeVars) termVars usedSchemeVars
+              params = Typing.functionStructureParams fs
+              bindings = Typing.functionStructureBindings fs
+              body = Typing.functionStructureBody fs
+              doms = Typing.functionStructureDomains fs
+              env2 = Typing.functionStructureEnvironment fs
+              schemeType = Core.typeSchemeBody ts
+              numParams = Lists.length params
+              peelResult = peelDomainsAndCod numParams schemeType
+              schemeDoms = Pairs.first peelResult
+              cod = Pairs.second peelResult
+              schemeVarSet = Sets.fromList tparams
+          in (Eithers.bind (Logic.ifElse (Lists.null tparams) (Right Maps.empty) (buildSubstFromAnnotations schemeVarSet term cx g)) (\typeVarSubst ->
+            let overgenSubst = detectAccumulatorUnification schemeDoms cod tparams
+                overgenVarSubst =
+                        Maps.fromList (Optionals.cat (Lists.map (\entry ->
+                          let k = Pairs.first entry
+                              v = Pairs.second entry
+                          in case v of
+                            Core.TypeVariable v0 -> Just (k, v0)
+                            _ -> Nothing) (Maps.toList overgenSubst)))
+                fixedCod = Logic.ifElse (Maps.null overgenSubst) cod (substituteTypeVarsWithTypes overgenSubst cod)
+                fixedDoms =
+                        Logic.ifElse (Maps.null overgenSubst) schemeDoms (Lists.map (\d -> substituteTypeVarsWithTypes overgenSubst d) schemeDoms)
+                fixedTparams =
+                        Logic.ifElse (Maps.null overgenSubst) tparams (Lists.filter (\v -> Logic.not (Maps.member v overgenSubst)) tparams)
+                constraints = Optionals.fromOptional Maps.empty (Core.typeSchemeConstraints ts)
+                jparams = Lists.map (\v -> Utils.javaTypeParameter (Formatting.capitalize (Core.unName v))) fixedTparams
+                aliases2base = JavaEnvironment.javaEnvironmentAliases env2
+                trustedVars = Sets.unions (Lists.map (\d -> collectTypeVars d) (Lists.concat2 fixedDoms [
+                      fixedCod]))
+                fixedSchemeVarSet = Sets.fromList fixedTparams
+                aliases2 =
+                        JavaEnvironment.Aliases {
+                          JavaEnvironment.aliasesCurrentNamespace = (JavaEnvironment.aliasesCurrentNamespace aliases2base),
+                          JavaEnvironment.aliasesPackages = (JavaEnvironment.aliasesPackages aliases2base),
+                          JavaEnvironment.aliasesBranchVars = (JavaEnvironment.aliasesBranchVars aliases2base),
+                          JavaEnvironment.aliasesRecursiveVars = (JavaEnvironment.aliasesRecursiveVars aliases2base),
+                          JavaEnvironment.aliasesInScopeTypeParams = fixedSchemeVarSet,
+                          JavaEnvironment.aliasesPolymorphicLocals = (JavaEnvironment.aliasesPolymorphicLocals aliases2base),
+                          JavaEnvironment.aliasesInScopeJavaVars = (JavaEnvironment.aliasesInScopeJavaVars aliases2base),
+                          JavaEnvironment.aliasesVarRenames = (JavaEnvironment.aliasesVarRenames aliases2base),
+                          JavaEnvironment.aliasesLambdaVars = (Sets.union (JavaEnvironment.aliasesLambdaVars aliases2base) (Sets.fromList params)),
+                          JavaEnvironment.aliasesTypeVarSubst = (Maps.union overgenVarSubst typeVarSubst),
+                          JavaEnvironment.aliasesTrustedTypeVars = (Sets.intersection trustedVars fixedSchemeVarSet),
+                          JavaEnvironment.aliasesMethodCodomain = (Just fixedCod),
+                          JavaEnvironment.aliasesThunkedVars = (JavaEnvironment.aliasesThunkedVars aliases2base)}
+                env2WithTypeParams =
+                        JavaEnvironment.JavaEnvironment {
+                          JavaEnvironment.javaEnvironmentAliases = aliases2,
+                          JavaEnvironment.javaEnvironmentGraph = (JavaEnvironment.javaEnvironmentGraph env2)}
+            in (Eithers.bind (bindingsToStatements env2WithTypeParams bindings cx g) (\bindResult ->
+              let bindingStmts = Pairs.first bindResult
+                  env3 = Pairs.second bindResult
+              in (Eithers.bind (Logic.ifElse (Maps.null overgenSubst) (Right body) (applyOvergenSubstToTermAnnotations overgenSubst body cx g)) (\body_ ->
+                let annotatedBody = propagateTypesInAppChain fixedCod fixedCod body_
+                in (Eithers.bind (Eithers.mapList (\pair -> Eithers.bind (encodeType aliases2 Sets.empty (Pairs.first pair) cx g) (\jdom -> Right (Utils.javaTypeToJavaFormalParameter jdom (Pairs.second pair)))) (Lists.zip fixedDoms params)) (\jformalParams -> Eithers.bind (encodeType aliases2 Sets.empty fixedCod cx g) (\jcod ->
+                  let result = Utils.javaTypeToJavaResult jcod
+                      mods = [
+                            Syntax.InterfaceMethodModifierStatic]
+                      jname = Utils.sanitizeJavaName (Formatting.decapitalize (Names.localNameOf name))
+                      isTCO = False
+                  in (Eithers.bind (Logic.ifElse isTCO (
+                    let tcoSuffix = "_tco"
+                        snapshotNames = Lists.map (\p -> Core.Name (Strings.cat2 (Core.unName p) tcoSuffix)) params
+                        tcoVarRenames = Maps.fromList (Lists.zip params snapshotNames)
+                        snapshotDecls =
+                                Lists.map (\pair -> Utils.finalVarDeclarationStatement (Utils.variableToJavaIdentifier (Pairs.second pair)) (Utils.javaIdentifierToJavaExpression (Utils.variableToJavaIdentifier (Pairs.first pair)))) (Lists.zip params snapshotNames)
+                        tcoBody =
+                                Logic.ifElse (Lists.null bindings) annotatedBody (Core.TermLet (Core.Let {
+                                  Core.letBindings = bindings,
+                                  Core.letBody = annotatedBody}))
+                    in (Eithers.bind (encodeTermTCO env2WithTypeParams name params tcoVarRenames 0 tcoBody cx g) (\tcoStmts ->
+                      let whileBodyStmts = Lists.concat2 snapshotDecls tcoStmts
+                          whileBodyBlock =
+                                  Syntax.StatementWithoutTrailing (Syntax.StatementWithoutTrailingSubstatementBlock (Syntax.Block whileBodyStmts))
+                          noCond = Nothing
+                          whileStmt =
+                                  Syntax.BlockStatementStatement (Syntax.StatementWhile (Syntax.WhileStatement {
+                                    Syntax.whileStatementCond = noCond,
+                                    Syntax.whileStatementBody = whileBodyBlock}))
+                      in (Right [
+                        whileStmt])))) (Eithers.bind (encodeTerm env3 annotatedBody cx g) (\jbody ->
+                    let returnSt = Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just jbody))
+                    in (Right (Lists.concat2 bindingStmts [
+                      returnSt]))))) (\methodBody ->
+                    let imdMember = Utils.interfaceMethodDeclaration mods jparams jname jformalParams result (Just methodBody)
+                    in (Right (Optionals.cases mDoc (noInterfaceComment imdMember) (\doc -> withInterfaceCommentString doc imdMember))))))))))))))))))
+
+encodeTermInternal :: JavaEnvironment.JavaEnvironment -> [M.Map Core.Name Core.Term] -> [Syntax.Type] -> Core.Term -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeTermInternal env anns tyapps term cx g0 =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+          g = JavaEnvironment.javaEnvironmentGraph env
+          encode = \t -> encodeTerm env t cx g
+      in case term of
+        Core.TermAnnotated v0 -> encodeTermInternal env (Lists.cons (Annotations.getAnnotationMap (Core.annotatedTermAnnotation v0)) anns) tyapps (Core.annotatedTermBody v0) cx g
+        Core.TermApplication v0 -> encodeApplication env v0 cx g
+        Core.TermEither v0 -> Eithers.bind (Logic.ifElse (Lists.null tyapps) (Right Nothing) (Eithers.bind (takeTypeArgs "either" 2 tyapps cx g) (\ta -> Right (Just ta)))) (\mtargs ->
+          let combinedAnns = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+          in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnns)) (\mEitherType ->
+            let branchTypes =
+                    Optionals.bind mEitherType (\etyp -> case (Strip.deannotateType etyp) of
+                      Core.TypeEither v1 -> Just (Core.eitherTypeLeft v1, (Core.eitherTypeRight v1))
+                      _ -> Nothing)
+                encodeWithType =
+                        \branchType -> \t1 ->
+                          let annotated = Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ branchType)) t1
+                          in (encodeTermInternal env anns [] annotated cx g)
+                eitherCall =
+                        \methodName -> \expr -> Optionals.cases mtargs (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic (Syntax.Identifier "hydra.overlay.java.util.Either") (Syntax.Identifier methodName) [
+                          expr])) (\targs -> Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.Either") (Syntax.Identifier methodName) targs [
+                          expr]))
+            in (Eithers.either (\term1 -> Eithers.bind (Optionals.cases branchTypes (encode term1) (\bt -> encodeWithType (Pairs.first bt) term1)) (\expr -> Right (eitherCall "left" expr))) (\term1 -> Eithers.bind (Optionals.cases branchTypes (encode term1) (\bt -> encodeWithType (Pairs.second bt) term1)) (\expr -> Right (eitherCall "right" expr))) v0))))
+        Core.TermLambda _ -> encodeFunctionFormTerm env anns term cx g
+        Core.TermProject _ -> encodeFunctionFormTerm env anns term cx g
+        Core.TermCases _ -> encodeFunctionFormTerm env anns term cx g
+        Core.TermUnwrap _ -> encodeFunctionFormTerm env anns term cx g
+        Core.TermLet v0 ->
+          let bindings = Core.letBindings v0
+              body = Core.letBody v0
+          in (Logic.ifElse (Lists.null bindings) (encodeTermInternal env anns [] body cx g) (Eithers.bind (bindingsToStatements env bindings cx g) (\bindResult ->
+            let bindingStmts = Pairs.first bindResult
+                env2 = Pairs.second bindResult
+            in (Eithers.bind (encodeTermInternal env2 anns [] body cx g) (\jbody ->
+              let returnSt = Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just jbody))
+                  block = Syntax.Block (Lists.concat2 bindingStmts [
+                        returnSt])
+                  nullaryLambda =
+                          Syntax.ExpressionLambda (Syntax.LambdaExpression {
+                            Syntax.lambdaExpressionParameters = (Syntax.LambdaParametersTuple []),
+                            Syntax.lambdaExpressionBody = (Syntax.LambdaBodyBlock block)})
+                  combinedAnns = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+                  g2 = JavaEnvironment.javaEnvironmentGraph env2
+                  aliases2 = JavaEnvironment.javaEnvironmentAliases env2
+              in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnns)) (\mt -> Eithers.bind (Optionals.cases mt (Checking.typeOfTerm cx g2 body) (\t -> Right t)) (\letType -> Eithers.bind (encodeType aliases2 Sets.empty letType cx g) (\jLetType -> Eithers.bind (Utils.javaTypeToJavaReferenceType jLetType cx) (\rt ->
+                let supplierRt =
+                        Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeClass (Utils.javaClassType [
+                          rt] JavaNames.javaUtilFunctionPackageName "Supplier"))
+                    castExpr =
+                            Utils.javaCastExpressionToJavaExpression (Utils.javaCastExpression supplierRt (Utils.javaExpressionToJavaUnaryExpression nullaryLambda))
+                in (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocation (Just (Right (Utils.javaExpressionToJavaPrimary castExpr))) (Syntax.Identifier "get") [])))))))))))))
+        Core.TermList v0 -> Logic.ifElse (Lists.null v0) (Logic.ifElse (Lists.null tyapps) (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic (Syntax.Identifier "hydra.overlay.java.util.ConsList") (Syntax.Identifier "empty") []))) (Eithers.bind (takeTypeArgs "list" 1 tyapps cx g) (\targs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.ConsList") (Syntax.Identifier "empty") targs []))))) (Eithers.bind (Eithers.mapList encode v0) (\jels -> Eithers.bind (collectionTypeArgs "list" 1 aliases anns tyapps cx g) (\targs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.ConsList") (Syntax.Identifier "of") targs jels)))))
+        Core.TermLiteral v0 -> Right (encodeLiteral v0)
+        Core.TermMap v0 -> Logic.ifElse (Maps.null v0) (Logic.ifElse (Lists.null tyapps) (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic (Syntax.Identifier "hydra.overlay.java.util.PersistentMap") (Syntax.Identifier "empty") []))) (Eithers.bind (takeTypeArgs "map" 2 tyapps cx g) (\targs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.PersistentMap") (Syntax.Identifier "empty") targs []))))) (Eithers.bind (Eithers.mapList encode (Maps.keys v0)) (\jkeys -> Eithers.bind (Eithers.mapList encode (Maps.elems v0)) (\jvals ->
+          let pairExprs =
+                  Lists.map (\kv -> Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic (Syntax.Identifier "java.util.Map") (Syntax.Identifier "entry") [
+                    Pairs.first kv,
+                    (Pairs.second kv)])) (Lists.zip jkeys jvals)
+          in (Eithers.bind (collectionTypeArgs "map" 2 aliases anns tyapps cx g) (\targs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.PersistentMap") (Syntax.Identifier "ofEntries") targs pairExprs)))))))
+        Core.TermOptional v0 -> Optionals.cases v0 (Logic.ifElse (Lists.null tyapps) (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic (Syntax.Identifier "hydra.overlay.java.util.Optional") (Syntax.Identifier "none") []))) (Eithers.bind (takeTypeArgs "optional" 1 tyapps cx g) (\targs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.Optional") (Syntax.Identifier "none") targs []))))) (\term1 -> Eithers.bind (encode term1) (\expr -> Eithers.bind (collectionTypeArgs "optional" 1 aliases anns tyapps cx g) (\targs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.Optional") (Syntax.Identifier "given") targs [
+          expr])))))
+        Core.TermPair v0 -> Eithers.bind (encode (Pairs.first v0)) (\jterm1 -> Eithers.bind (encode (Pairs.second v0)) (\jterm2 -> Eithers.bind (Logic.ifElse (Lists.null tyapps) (Right Nothing) (Eithers.bind (Eithers.mapList (\jt -> Utils.javaTypeToJavaReferenceType jt cx) tyapps) (\rts -> Right (Just (Syntax.TypeArgumentsOrDiamondArguments (Lists.map (\rt -> Syntax.TypeArgumentReference rt) rts)))))) (\mtargs -> Right (Utils.javaConstructorCall (Utils.javaConstructorName (Syntax.Identifier "hydra.overlay.java.util.Pair") mtargs) [
+          jterm1,
+          jterm2] Nothing))))
+        Core.TermRecord v0 ->
+          let recName = Core.recordTypeName v0
+              mRecordType = Eithers.either (\_ -> Nothing) (\t -> Just t) (Resolution.requireType cx g recName)
+              strippedRecTyp = Optionals.map (\recTyp -> stripForalls (Strip.deannotateType recTyp)) mRecordType
+              mFieldTypeMap =
+                      Optionals.bind strippedRecTyp (\bodyTyp -> case bodyTyp of
+                        Core.TypeRecord v1 -> Just (Maps.fromList (Lists.map (\ft -> (Core.fieldTypeName ft, (Core.fieldTypeType ft))) v1))
+                        _ -> Nothing)
+              combinedAnnsRec = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+          in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnnsRec)) (\mAnnotType ->
+            let mTypeSubst =
+                    Optionals.bind mAnnotType (\annTyp -> Optionals.bind mRecordType (\recTyp ->
+                      let args = extractTypeApplicationArgs (Strip.deannotateType annTyp)
+                          params = collectForallParams (Strip.deannotateType recTyp)
+                      in (Logic.ifElse (Logic.or (Lists.null args) (Logic.not (Equality.equal (Lists.length args) (Lists.length params)))) Nothing (Just (Maps.fromList (Lists.zip params args))))))
+                encodeField =
+                        \fld -> Optionals.cases mFieldTypeMap (encode (Core.fieldTerm fld)) (\ftmap ->
+                          let mftyp = Maps.lookup (Core.fieldName fld) ftmap
+                          in (Optionals.cases mftyp (encode (Core.fieldTerm fld)) (\ftyp ->
+                            let resolvedType = Optionals.cases mTypeSubst ftyp (\subst -> applySubstFull subst ftyp)
+                                annotatedFieldTerm =
+                                        Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ resolvedType)) (Core.fieldTerm fld)
+                            in (encodeTermInternal env anns [] annotatedFieldTerm cx g))))
+            in (Eithers.bind (Eithers.mapList encodeField (Core.recordFields v0)) (\fieldExprs ->
+              let consId = Utils.nameToJavaName aliases recName
+              in (Eithers.bind (Logic.ifElse (Logic.not (Lists.null tyapps)) (Eithers.bind (Eithers.mapList (\jt -> Utils.javaTypeToJavaReferenceType jt cx) tyapps) (\rts -> Right (Just (Syntax.TypeArgumentsOrDiamondArguments (Lists.map (\rt -> Syntax.TypeArgumentReference rt) rts))))) (
+                let combinedAnns = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+                in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnns)) (\mtyp -> Optionals.cases mtyp (Right Nothing) (\annTyp ->
+                  let typeArgs = extractTypeApplicationArgs (Strip.deannotateType annTyp)
+                  in (Logic.ifElse (Lists.null typeArgs) (Right Nothing) (Eithers.bind (Eithers.mapList (\t -> Eithers.bind (encodeType aliases Sets.empty t cx g) (\jt -> Utils.javaTypeToJavaReferenceType jt cx)) typeArgs) (\jTypeArgs -> Right (Just (Syntax.TypeArgumentsOrDiamondArguments (Lists.map (\rt -> Syntax.TypeArgumentReference rt) jTypeArgs))))))))))) (\mtargs -> Right (Utils.javaConstructorCall (Utils.javaConstructorName consId mtargs) fieldExprs Nothing)))))))
+        Core.TermSet v0 -> Logic.ifElse (Sets.null v0) (Logic.ifElse (Lists.null tyapps) (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStatic (Syntax.Identifier "hydra.overlay.java.util.PersistentSet") (Syntax.Identifier "empty") []))) (Eithers.bind (takeTypeArgs "set" 1 tyapps cx g) (\targs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.PersistentSet") (Syntax.Identifier "empty") targs []))))) (
+          let slist = Sets.toList v0
+          in (Eithers.bind (Eithers.mapList encode slist) (\jels -> Eithers.bind (collectionTypeArgs "set" 1 aliases anns tyapps cx g) (\targs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.PersistentSet") (Syntax.Identifier "of") targs jels))))))
+        Core.TermTypeLambda v0 -> withTypeLambda env v0 (\env2 ->
+          let combinedAnns = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+          in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnns)) (\mtyp ->
+            let annotatedBody =
+                    Optionals.cases mtyp (Core.typeLambdaBody v0) (\t -> case t of
+                      Core.TypeForall v1 -> Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ (Core.forallTypeBody v1))) (Core.typeLambdaBody v0)
+                      _ -> Core.typeLambdaBody v0)
+            in (encodeTerm env2 annotatedBody cx g))))
+        Core.TermInject v0 ->
+          let injTypeName = Core.injectionTypeName v0
+              injField = Core.injectionField v0
+              injFieldName = Core.fieldName injField
+              injFieldTerm = Core.fieldTerm injField
+              typeId = Syntax.unIdentifier (Utils.nameToJavaName aliases injTypeName)
+              consId =
+                      Syntax.Identifier (Strings.cat [
+                        typeId,
+                        ".",
+                        (Utils.sanitizeJavaName (Formatting.capitalize (Core.unName injFieldName)))])
+          in (Eithers.bind (isFieldUnitType injTypeName injFieldName cx g) (\fieldIsUnit -> Eithers.bind (Logic.ifElse (Logic.or (Predicates.isUnitTerm (Strip.deannotateTerm injFieldTerm)) fieldIsUnit) (Right []) (Eithers.bind (encode injFieldTerm) (\ex -> Right [
+            ex]))) (\args -> Right (Utils.javaConstructorCall (Utils.javaConstructorName consId Nothing) args Nothing))))
+        Core.TermVariable v0 -> Optionals.cases (Maps.lookup v0 (Graph.graphPrimitives g)) (encodeVariable env v0 cx g) (\_ ->
+          let combinedAnns = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+          in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnns)) (\mt -> Eithers.bind (Optionals.cases mt (Checking.typeOfTerm cx g term) (\t -> Right t)) (\typ -> case (Strip.deannotateType typ) of
+            Core.TypeFunction v1 -> encodeFunctionPrimitiveByName env (Core.functionTypeDomain v1) (Core.functionTypeCodomain v1) v0 cx g
+            _ -> encodeNullaryPrimitiveByName env typ v0 cx g))))
+        Core.TermUnit -> Right (Utils.javaLiteralToJavaExpression Syntax.LiteralNull)
+        Core.TermWrap v0 -> Eithers.bind (encode (Core.wrappedTermBody v0)) (\jarg -> Right (Utils.javaConstructorCall (Utils.javaConstructorName (Utils.nameToJavaName aliases (Core.wrappedTermTypeName v0)) Nothing) [
+          jarg] Nothing))
+        Core.TermTypeApplication v0 ->
+          let atyp = Core.typeApplicationTermType v0
+              body = Core.typeApplicationTermBody v0
+          in (Eithers.bind (encodeType aliases Sets.empty atyp cx g) (\jatyp ->
+            let combinedAnns = Lists.foldl (\acc -> \m -> Maps.union acc m) Maps.empty anns
+            in (Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g combinedAnns)) (\mtyp -> Eithers.bind (Optionals.cases mtyp (Checking.typeOfTerm cx g term) (\t -> Right t)) (\typ ->
+              let collected0 = collectTypeApps0 body [
+                    atyp]
+                  innermostBody0 = Pairs.first collected0
+                  allTypeArgs0 = Pairs.second collected0
+              in (Eithers.bind (correctCastType innermostBody0 allTypeArgs0 typ cx g) (\correctedTyp ->
+                let collected = collectTypeApps body [
+                      atyp]
+                    innermostBody = Pairs.first collected
+                    allTypeArgs = Pairs.second collected
+                in case innermostBody of
+                  Core.TermVariable v1 -> Eithers.bind (classifyDataReference v1 cx g) (\cls -> typeAppNullaryOrHoisted env aliases anns tyapps jatyp body correctedTyp v1 cls allTypeArgs cx g)
+                  Core.TermEither v1 -> Logic.ifElse (Equality.equal (Lists.length allTypeArgs) 2) (
+                    let eitherBranchTypes =
+                            (
+                              Optionals.fromOptional correctedTyp (Lists.maybeAt 0 allTypeArgs),
+                              (Optionals.fromOptional correctedTyp (Lists.maybeAt 1 allTypeArgs)))
+                    in (Eithers.bind (Eithers.mapList (\t -> Eithers.bind (encodeType aliases Sets.empty t cx g) (\jt -> Utils.javaTypeToJavaReferenceType jt cx)) allTypeArgs) (\jTypeArgs ->
+                      let eitherTargs = Lists.map (\rt -> Syntax.TypeArgumentReference rt) jTypeArgs
+                          encodeEitherBranch =
+                                  \branchType -> \t1 ->
+                                    let annotated = Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ branchType)) t1
+                                    in (encodeTermInternal env anns [] annotated cx g)
+                      in (Eithers.either (\term1 -> Eithers.bind (encodeEitherBranch (Pairs.first eitherBranchTypes) term1) (\expr -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.Either") (Syntax.Identifier "left") eitherTargs [
+                        expr])))) (\term1 -> Eithers.bind (encodeEitherBranch (Pairs.second eitherBranchTypes) term1) (\expr -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs (Syntax.Identifier "hydra.overlay.java.util.Either") (Syntax.Identifier "right") eitherTargs [
+                        expr])))) v1)))) (typeAppFallbackCast env aliases anns tyapps jatyp body correctedTyp cx g)
+                  _ -> typeAppFallbackCast env aliases anns tyapps jatyp body correctedTyp cx g)))))))
+        _ -> Right (encodeLiteral (Core.LiteralString "Unimplemented term variant"))
+
+encodeTermTCO :: JavaEnvironment.JavaEnvironment -> Core.Name -> [Core.Name] -> M.Map Core.Name Core.Name -> Int -> Core.Term -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error [Syntax.BlockStatement]
+encodeTermTCO env0 funcName paramNames tcoVarRenames tcoDepth term cx g =
+
+      let aliases0 = JavaEnvironment.javaEnvironmentAliases env0
+          env =
+                  JavaEnvironment.JavaEnvironment {
+                    JavaEnvironment.javaEnvironmentAliases = JavaEnvironment.Aliases {
+                      JavaEnvironment.aliasesCurrentNamespace = (JavaEnvironment.aliasesCurrentNamespace aliases0),
+                      JavaEnvironment.aliasesPackages = (JavaEnvironment.aliasesPackages aliases0),
+                      JavaEnvironment.aliasesBranchVars = (JavaEnvironment.aliasesBranchVars aliases0),
+                      JavaEnvironment.aliasesRecursiveVars = (JavaEnvironment.aliasesRecursiveVars aliases0),
+                      JavaEnvironment.aliasesInScopeTypeParams = (JavaEnvironment.aliasesInScopeTypeParams aliases0),
+                      JavaEnvironment.aliasesPolymorphicLocals = (JavaEnvironment.aliasesPolymorphicLocals aliases0),
+                      JavaEnvironment.aliasesInScopeJavaVars = (JavaEnvironment.aliasesInScopeJavaVars aliases0),
+                      JavaEnvironment.aliasesVarRenames = (Maps.union tcoVarRenames (JavaEnvironment.aliasesVarRenames aliases0)),
+                      JavaEnvironment.aliasesLambdaVars = (JavaEnvironment.aliasesLambdaVars aliases0),
+                      JavaEnvironment.aliasesTypeVarSubst = (JavaEnvironment.aliasesTypeVarSubst aliases0),
+                      JavaEnvironment.aliasesTrustedTypeVars = (JavaEnvironment.aliasesTrustedTypeVars aliases0),
+                      JavaEnvironment.aliasesMethodCodomain = (JavaEnvironment.aliasesMethodCodomain aliases0),
+                      JavaEnvironment.aliasesThunkedVars = (JavaEnvironment.aliasesThunkedVars aliases0)},
+                    JavaEnvironment.javaEnvironmentGraph = (JavaEnvironment.javaEnvironmentGraph env0)}
+          stripped = Strip.deannotateAndDetypeTerm term
+          gathered = Analysis.gatherApplications stripped
+          gatherArgs = Pairs.first gathered
+          gatherFun = Pairs.second gathered
+          strippedFun = Strip.deannotateAndDetypeTerm gatherFun
+          isSelfCall =
+                  case strippedFun of
+                    Core.TermVariable v0 -> Equality.equal v0 funcName
+                    _ -> False
+      in (Logic.ifElse (Logic.and isSelfCall (Equality.equal (Lists.length gatherArgs) (Lists.length paramNames))) (
+        let changePairs =
+                Lists.filter (\pair -> Logic.not (case (Strip.deannotateAndDetypeTerm (Pairs.second pair)) of
+                  Core.TermVariable v0 -> Equality.equal v0 (Pairs.first pair)
+                  _ -> False)) (Lists.zip paramNames gatherArgs)
+            changedParams = Lists.map Pairs.first changePairs
+        in (Eithers.bind (Eithers.mapList (\pair -> encodeTerm env (Pairs.second pair) cx g) changePairs) (\jChangedArgs ->
+          let assignments =
+                  Lists.map (\pair ->
+                    let paramName = Pairs.first pair
+                        jArg = Pairs.second pair
+                    in (Syntax.BlockStatementStatement (Utils.javaAssignmentStatement (Syntax.LeftHandSideExpressionName (Utils.javaIdentifierToJavaExpressionName (Utils.variableToJavaIdentifier paramName))) jArg))) (Lists.zip changedParams jChangedArgs)
+              continueStmt =
+                      Syntax.BlockStatementStatement (Syntax.StatementWithoutTrailing (Syntax.StatementWithoutTrailingSubstatementContinue (Syntax.ContinueStatement Nothing)))
+          in (Right (Lists.concat2 assignments [
+            continueStmt]))))) (case stripped of
+        Core.TermLet v0 ->
+          let letBindings = Core.letBindings v0
+              letBody = Core.letBody v0
+          in (Eithers.bind (bindingsToStatements env letBindings cx g) (\bindResult ->
+            let letStmts = Pairs.first bindResult
+                envAfterLet = Pairs.second bindResult
+            in (Eithers.bind (encodeTermTCO envAfterLet funcName paramNames tcoVarRenames tcoDepth letBody cx g) (\tcoBodyStmts -> Right (Lists.concat2 letStmts tcoBodyStmts)))))
+        _ ->
+          let gathered2 = Analysis.gatherApplications term
+              args2 = Pairs.first gathered2
+              body2 = Pairs.second gathered2
+          in (Logic.ifElse (Equality.equal (Lists.length args2) 1) (
+            let arg = Optionals.fromOptional Core.TermUnit (Lists.maybeHead args2)
+            in case (Strip.deannotateAndDetypeTerm body2) of
+              Core.TermCases v0 ->
+                let aliases = JavaEnvironment.javaEnvironmentAliases env
+                    tname = Core.caseStatementTypeName v0
+                    dflt = Core.caseStatementDefault v0
+                    cases_ = Core.caseStatementCases v0
+                in (Eithers.bind (domTypeArgs aliases (Resolution.nominalApplication tname []) cx g) (\domArgs -> Eithers.bind (encodeTerm env arg cx g) (\jArgRaw ->
+                  let depthSuffix = Logic.ifElse (Equality.equal tcoDepth 0) "" (Literals.showInt32 tcoDepth)
+                      matchVarId =
+                              Utils.javaIdentifier (Strings.cat [
+                                "_tco_match_",
+                                (Formatting.decapitalize (Names.localNameOf tname)),
+                                depthSuffix])
+                      matchDecl = Utils.varDeclarationStatement matchVarId jArgRaw
+                      jArg = Utils.javaIdentifierToJavaExpression matchVarId
+                  in (Eithers.bind (Eithers.mapList (\field ->
+                    let fieldName = Core.caseAlternativeName field
+                        variantRefType =
+                                Utils.nameToJavaReferenceType aliases True domArgs tname (Just (Formatting.capitalize (Core.unName fieldName)))
+                    in case (Strip.deannotateTerm (Core.caseAlternativeHandler field)) of
+                      Core.TermLambda v1 -> withLambda env v1 (\env2 ->
+                        let lambdaParam = Core.lambdaParameter v1
+                            branchBody = Core.lambdaBody v1
+                            env3 = insertBranchVar lambdaParam env2
+                            varId = Utils.variableToJavaIdentifier lambdaParam
+                            castExpr =
+                                    Utils.javaCastExpressionToJavaExpression (Utils.javaCastExpression variantRefType (Utils.javaExpressionToJavaUnaryExpression jArg))
+                            localDecl = Utils.varDeclarationStatement varId castExpr
+                            isBranchTailCall = Analysis.isTailRecursiveInTailPosition funcName branchBody
+                        in (Eithers.bind (Logic.ifElse isBranchTailCall (encodeTermTCO env3 funcName paramNames tcoVarRenames (Math.add tcoDepth 1) branchBody cx g) (Eithers.bind (analyzeJavaFunction env3 branchBody cx g) (\fs ->
+                          let bindings = Typing.functionStructureBindings fs
+                              innerBody = Typing.functionStructureBody fs
+                              env4 = Typing.functionStructureEnvironment fs
+                          in (Eithers.bind (bindingsToStatements env4 bindings cx g) (\bindResult ->
+                            let bindingStmts = Pairs.first bindResult
+                                env5 = Pairs.second bindResult
+                            in (Eithers.bind (encodeTerm env5 innerBody cx g) (\jret ->
+                              let returnStmt = Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just jret))
+                              in (Right (Lists.concat2 bindingStmts [
+                                returnStmt]))))))))) (\bodyStmts ->
+                          let relExpr =
+                                  Utils.javaInstanceOf (Utils.javaUnaryExpressionToJavaRelationalExpression (Utils.javaExpressionToJavaUnaryExpression jArg)) variantRefType
+                              condExpr = Utils.javaRelationalExpressionToJavaExpression relExpr
+                              blockStmts = Lists.cons localDecl bodyStmts
+                              ifBody = Syntax.StatementWithoutTrailing (Syntax.StatementWithoutTrailingSubstatementBlock (Syntax.Block blockStmts))
+                          in (Right (Syntax.BlockStatementStatement (Syntax.StatementIfThen (Syntax.IfThenStatement {
+                            Syntax.ifThenStatementExpression = condExpr,
+                            Syntax.ifThenStatementStatement = ifBody})))))))
+                      _ -> Left (Errors.ErrorOther (Errors.OtherError "TCO: case branch is not a lambda"))) cases_) (\ifBlocks -> Eithers.bind (Optionals.cases dflt (Right [
+                    Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just jArg))]) (\d -> Eithers.bind (encodeTerm env d cx g) (\dExpr -> Right [
+                    Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just dExpr))]))) (\defaultStmt -> Right (Lists.concat [
+                    [
+                      matchDecl],
+                    ifBlocks,
+                    defaultStmt])))))))
+              _ -> Eithers.bind (encodeTerm env term cx g) (\expr -> Right [
+                Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just expr))])) (Eithers.bind (encodeTerm env term cx g) (\expr -> Right [
+            Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just expr))])))))
+
+encodeType :: JavaEnvironment.Aliases -> S.Set Core.Name -> Core.Type -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Type
+encodeType aliases boundVars t cx g =
+
+      let inScopeTypeParams = JavaEnvironment.aliasesInScopeTypeParams aliases
+          typeVarSubst = JavaEnvironment.aliasesTypeVarSubst aliases
+      in case (Strip.deannotateType t) of
+        Core.TypeApplication v0 -> Eithers.bind (encodeType aliases boundVars (Core.applicationTypeFunction v0) cx g) (\jlhs -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.applicationTypeArgument v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jrhs -> Utils.addJavaTypeParameter jrhs jlhs cx))
+        Core.TypeFunction v0 -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.functionTypeDomain v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jdom -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.functionTypeCodomain v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jcod -> Right (Utils.javaRefType [
+          jdom,
+          jcod] JavaNames.javaUtilFunctionPackageName "Function")))
+        Core.TypeForall v0 -> Eithers.bind (encodeType aliases (Sets.insert (Core.forallTypeParameter v0) boundVars) (Core.forallTypeBody v0) cx g) (\jbody -> Utils.addJavaTypeParameter (Utils.javaTypeVariable (Core.unName (Core.forallTypeParameter v0))) jbody cx)
+        Core.TypeList v0 -> Eithers.bind (encodeType aliases boundVars v0 cx g) (\jet -> Eithers.bind (Eithers.bind (Right jet) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\rt -> Right (Utils.javaRefType [
+          rt] JavaNames.javaUtilPackageName "List")))
+        Core.TypeEffect v0 -> encodeType aliases boundVars v0 cx g
+        Core.TypeLiteral v0 -> encodeLiteralType v0 cx g
+        Core.TypeEither v0 -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.eitherTypeLeft v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jlt -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.eitherTypeRight v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jrt -> Right (Utils.javaRefType [
+          jlt,
+          jrt] JavaNames.hydraUtilPackageName "Either")))
+        Core.TypeMap v0 -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.mapTypeKeys v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jkt -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.mapTypeValues v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jvt -> Right (Utils.javaRefType [
+          jkt,
+          jvt] JavaNames.javaUtilPackageName "Map")))
+        Core.TypePair v0 -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.pairTypeFirst v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jfirst -> Eithers.bind (Eithers.bind (encodeType aliases boundVars (Core.pairTypeSecond v0) cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jsecond -> Right (Utils.javaRefType [
+          jfirst,
+          jsecond] JavaNames.hydraUtilPackageName "Pair")))
+        Core.TypeUnit -> Right (Utils.javaRefType [] JavaNames.javaLangPackageName "Void")
+        Core.TypeRecord v0 -> Logic.ifElse (Lists.null v0) (Right (Utils.javaRefType [] JavaNames.javaLangPackageName "Void")) (Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type")))
+        Core.TypeOptional v0 -> Eithers.bind (Eithers.bind (encodeType aliases boundVars v0 cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jot -> Right (Utils.javaRefType [
+          jot] JavaNames.hydraUtilPackageName "Optional"))
+        Core.TypeSet v0 -> Eithers.bind (Eithers.bind (encodeType aliases boundVars v0 cx g) (\jt_ -> Utils.javaTypeToJavaReferenceType jt_ cx)) (\jst -> Right (Utils.javaRefType [
+          jst] JavaNames.javaUtilPackageName "Set"))
+        Core.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type"))
+        Core.TypeVariable v0 ->
+          let name = Optionals.fromOptional v0 (Maps.lookup v0 typeVarSubst)
+          in (Eithers.bind (encodeType_resolveIfTypedef aliases boundVars inScopeTypeParams name cx g) (\resolved -> Optionals.cases resolved (Right (Logic.ifElse (Logic.or (Sets.member name boundVars) (Sets.member name inScopeTypeParams)) (Syntax.TypeReference (Utils.javaTypeVariable (Core.unName name))) (Logic.ifElse (isLambdaBoundVariable name) (Syntax.TypeReference (Utils.javaTypeVariable (Core.unName name))) (Logic.ifElse (isUnresolvedInferenceVar name) (Syntax.TypeReference (Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeClass (Utils.javaClassType [] JavaNames.javaLangPackageName "Object")))) (Syntax.TypeReference (Utils.nameToJavaReferenceType aliases True [] name Nothing)))))) (\resolvedType -> encodeType aliases boundVars resolvedType cx g)))
+        Core.TypeWrap _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous wrap type"))
+        _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "can't encode unsupported type in Java: " (ShowCore.type_ t))))
+
+encodeTypeDefinition :: Syntax.PackageDeclaration -> JavaEnvironment.Aliases -> Packaging.TypeDefinition -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error (Core.Name, Syntax.CompilationUnit)
+encodeTypeDefinition pkg aliases tdef cx g =
+
+      let name = Packaging.typeDefinitionName tdef
+          typ = Core.typeSchemeBody (Packaging.typeDefinitionBody tdef)
+          serializable = isSerializableJavaType typ
+          imports =
+                  Logic.ifElse serializable [
+                    Syntax.ImportDeclarationSingleType (Syntax.SingleTypeImportDeclaration (Utils.javaTypeName (Syntax.Identifier "java.io.Serializable")))] []
+      in (Eithers.bind (toClassDecl False serializable aliases [] name typ cx g) (\decl -> Eithers.bind (Annotations.getTypeDescription cx g typ) (\comment ->
+        let tdecl =
+                Syntax.TopLevelClassOrInterfaceDeclarationWithComments {
+                  Syntax.topLevelClassOrInterfaceDeclarationWithCommentsValue = (Syntax.TopLevelClassOrInterfaceDeclarationClass decl),
+                  Syntax.topLevelClassOrInterfaceDeclarationWithCommentsComments = comment}
+        in (Right (
+          name,
+          (Syntax.CompilationUnitOrdinary (Syntax.OrdinaryCompilationUnit {
+            Syntax.ordinaryCompilationUnitPackage = (Just pkg),
+            Syntax.ordinaryCompilationUnitImports = imports,
+            Syntax.ordinaryCompilationUnitTypes = [
+              tdecl]})))))))
+
+encodeType_resolveIfTypedef :: t0 -> S.Set Core.Name -> S.Set Core.Name -> Core.Name -> t1 -> Graph.Graph -> Either t2 (Maybe Core.Type)
+encodeType_resolveIfTypedef aliases boundVars inScopeTypeParams name cx g =
+    Logic.ifElse (Logic.or (Sets.member name boundVars) (Sets.member name inScopeTypeParams)) (Right Nothing) (Logic.ifElse (isLambdaBoundVariable name) (Right Nothing) (
+      let schemaTypes = Graph.graphSchemaTypes g
+      in (Optionals.cases (Maps.lookup name schemaTypes) (Right Nothing) (\ts -> Logic.ifElse (Logic.not (Lists.null (Core.typeSchemeVariables ts))) (Right Nothing) (case (Strip.deannotateType (Core.typeSchemeBody ts)) of
+        Core.TypeRecord _ -> Right Nothing
+        Core.TypeUnion _ -> Right Nothing
+        Core.TypeWrap _ -> Right Nothing
+        _ -> Right (Just (Core.typeSchemeBody ts)))))))
+
+encodeVariable :: JavaEnvironment.JavaEnvironment -> Core.Name -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeVariable env name cx g =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+          resolvedName = Utils.lookupJavaVarName aliases name
+          jid = Utils.javaIdentifier (Core.unName resolvedName)
+      in (Logic.ifElse (Sets.member name (JavaEnvironment.aliasesBranchVars aliases)) (Right (Utils.javaFieldAccessToJavaExpression (Syntax.FieldAccess {
+        Syntax.fieldAccessQualifier = (Syntax.FieldAccess_QualifierPrimary (Utils.javaExpressionToJavaPrimary (Utils.javaIdentifierToJavaExpression jid))),
+        Syntax.fieldAccessIdentifier = (Utils.javaIdentifier JavaNames.valueFieldName)}))) (Logic.ifElse (Logic.and (Equality.equal name (Core.Name (Strings.cat [
+        JavaNames.instanceName,
+        "_",
+        JavaNames.valueFieldName]))) (isRecursiveVariable aliases name)) (
+        let instanceExpr = Utils.javaIdentifierToJavaExpression (Utils.javaIdentifier JavaNames.instanceName)
+        in (Right (Utils.javaFieldAccessToJavaExpression (Syntax.FieldAccess {
+          Syntax.fieldAccessQualifier = (Syntax.FieldAccess_QualifierPrimary (Utils.javaExpressionToJavaPrimary instanceExpr)),
+          Syntax.fieldAccessIdentifier = (Utils.javaIdentifier JavaNames.valueFieldName)})))) (Logic.ifElse (Logic.and (isRecursiveVariable aliases name) (Logic.not (isLambdaBoundIn name (JavaEnvironment.aliasesLambdaVars aliases)))) (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocation (Just (Left (Syntax.ExpressionName {
+        Syntax.expressionNameQualifier = Nothing,
+        Syntax.expressionNameIdentifier = jid}))) (Syntax.Identifier JavaNames.getMethodName) []))) (Logic.ifElse (Logic.and (Sets.member name (JavaEnvironment.aliasesThunkedVars aliases)) (Logic.not (isLambdaBoundIn name (JavaEnvironment.aliasesLambdaVars aliases)))) (Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocation (Just (Left (Syntax.ExpressionName {
+        Syntax.expressionNameQualifier = Nothing,
+        Syntax.expressionNameIdentifier = jid}))) (Syntax.Identifier JavaNames.getMethodName) []))) (Logic.ifElse (isLambdaBoundIn name (JavaEnvironment.aliasesLambdaVars aliases)) (
+        let actualName = findMatchingLambdaVar name (JavaEnvironment.aliasesLambdaVars aliases)
+            resolvedActual = Utils.lookupJavaVarName aliases actualName
+        in (Right (Utils.javaIdentifierToJavaExpression (Utils.variableToJavaIdentifier resolvedActual)))) (Logic.ifElse (Sets.member name (JavaEnvironment.aliasesInScopeJavaVars aliases)) (Right (Utils.javaIdentifierToJavaExpression (elementJavaIdentifier False False aliases resolvedName))) (Eithers.bind (classifyDataReference name cx g) (\cls -> case cls of
+        JavaEnvironment.JavaSymbolClassHoistedLambda v0 -> encodeVariable_hoistedLambdaCase aliases name v0 cx g
+        JavaEnvironment.JavaSymbolClassLocalVariable -> Right (Utils.javaIdentifierToJavaExpression (elementJavaIdentifier False False aliases resolvedName))
+        JavaEnvironment.JavaSymbolClassConstant -> Right (Utils.javaIdentifierToJavaExpression (elementJavaIdentifier False False aliases name))
+        JavaEnvironment.JavaSymbolClassNullaryFunction -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocation Nothing (elementJavaIdentifier False False aliases name) []))
+        JavaEnvironment.JavaSymbolClassUnaryFunction -> Right (Utils.javaIdentifierToJavaExpression (elementJavaIdentifier False True aliases name))))))))))
+
+encodeVariable_buildCurried :: [Core.Name] -> Syntax.Expression -> Syntax.Expression
+encodeVariable_buildCurried params inner =
+    Optionals.fromOptional inner (Optionals.map (\p -> Utils.javaLambda (Pairs.first p) (encodeVariable_buildCurried (Pairs.second p) inner)) (Lists.uncons params))
+
+encodeVariable_hoistedLambdaCase :: JavaEnvironment.Aliases -> Core.Name -> Int -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression
+encodeVariable_hoistedLambdaCase aliases name arity cx g =
+
+      let paramNames = Lists.map (\i -> Core.Name (Strings.cat2 "p" (Literals.showInt32 i))) (Math.range 0 (Math.sub arity 1))
+          paramExprs = Lists.map (\pn -> Utils.javaIdentifierToJavaExpression (Utils.variableToJavaIdentifier pn)) paramNames
+          call =
+                  Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocation Nothing (elementJavaIdentifier False False aliases name) paramExprs)
+          lam = encodeVariable_buildCurried paramNames call
+      in (Eithers.bind (Right (Lexical.lookupBinding g name)) (\mel -> Optionals.cases mel (Right lam) (\el -> Optionals.cases (Core.bindingTypeScheme el) (Right lam) (\ts ->
+        let typ = Core.typeSchemeBody ts
+        in (Eithers.bind (encodeType aliases Sets.empty typ cx g) (\jtype -> Eithers.bind (Utils.javaTypeToJavaReferenceType jtype cx) (\rt -> Right (Utils.javaCastExpressionToJavaExpression (Utils.javaCastExpression rt (Utils.javaExpressionToJavaUnaryExpression lam))))))))))
+
+eqClause :: String -> Core.FieldType -> Syntax.InclusiveOrExpression
+eqClause tmpName ft =
+
+      let fname = Core.unName (Core.fieldTypeName ft)
+          ftype = Core.fieldTypeType ft
+      in (Logic.ifElse (isBinaryType ftype) (arraysEqualsClause tmpName fname) (Logic.ifElse (isBigNumericType ftype) (compareToZeroClause tmpName fname) (equalsClause tmpName fname)))
+
+equalsClause :: String -> String -> Syntax.InclusiveOrExpression
+equalsClause tmpName fname =
+
+      let thisArg =
+              Utils.javaExpressionNameToJavaExpression (Utils.fieldExpression (Syntax.Identifier "this") (Utils.javaIdentifier fname))
+          otherArg =
+                  Utils.javaExpressionNameToJavaExpression (Utils.fieldExpression (Utils.javaIdentifier tmpName) (Utils.javaIdentifier fname))
+          header =
+                  Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                    Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantType (Utils.javaTypeName (Syntax.Identifier "java.util.Objects"))),
+                    Syntax.methodInvocation_ComplexTypeArguments = [],
+                    Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier JavaNames.equalsMethodName)})
+      in (Utils.javaPostfixExpressionToJavaInclusiveOrExpression (Utils.javaMethodInvocationToJavaPostfixExpression (Syntax.MethodInvocation {
+        Syntax.methodInvocationHeader = header,
+        Syntax.methodInvocationArguments = [
+          thisArg,
+          otherArg]})))
+
+extractArgType :: t0 -> Core.Type -> Core.Type
+extractArgType _lhs typ =
+    case typ of
+      Core.TypeApplication v0 -> case (Core.applicationTypeFunction v0) of
+        Core.TypeApplication _ -> Core.applicationTypeArgument v0
+        _ -> typ
+      _ -> typ
+
+extractDirectReturn :: S.Set Core.Name -> Core.Type -> [(Core.Name, Core.Name)]
+extractDirectReturn tparamSet t = extractDirectReturn_go tparamSet t
+
+extractDirectReturn_go :: S.Set Core.Name -> Core.Type -> [(Core.Name, Core.Name)]
+extractDirectReturn_go tparamSet t =
+    case (Strip.deannotateType t) of
+      Core.TypeFunction v0 ->
+        let dom = Strip.deannotateType (Core.functionTypeDomain v0)
+            cod = Core.functionTypeCodomain v0
+        in case dom of
+          Core.TypeVariable v1 -> Logic.ifElse (Sets.member v1 tparamSet) (case (Strip.deannotateType cod) of
+            Core.TypeFunction v2 ->
+              let midArg = Strip.deannotateType (Core.functionTypeDomain v2)
+                  retPart = Strip.deannotateType (Core.functionTypeCodomain v2)
+              in case midArg of
+                Core.TypeVariable v3 -> Logic.ifElse (Sets.member v3 tparamSet) [] (case retPart of
+                  Core.TypeVariable v4 -> Logic.ifElse (Sets.member v4 tparamSet) [
+                    (v1, v4)] []
+                  _ -> [])
+                _ -> case retPart of
+                  Core.TypeVariable v3 -> Logic.ifElse (Sets.member v3 tparamSet) [
+                    (v1, v3)] []
+                  _ -> []
+            _ -> []) (extractDirectReturn_go tparamSet cod)
+          _ -> extractDirectReturn_go tparamSet cod
+      _ -> []
+
+extractInOutPair :: Core.Type -> [(Core.Name, Core.Name)]
+extractInOutPair t =
+    case (Strip.deannotateType t) of
+      Core.TypeFunction v0 -> case (Strip.deannotateType (Core.functionTypeDomain v0)) of
+        Core.TypeVariable v1 ->
+          let retType = unwrapReturnType (Core.functionTypeCodomain v0)
+          in case (Strip.deannotateType retType) of
+            Core.TypePair v2 -> case (Strip.deannotateType (Core.pairTypeFirst v2)) of
+              Core.TypeVariable v3 -> [
+                (v1, v3)]
+              _ -> []
+            _ -> []
+        _ -> []
+      _ -> []
+
+extractTypeApplicationArgs :: Core.Type -> [Core.Type]
+extractTypeApplicationArgs typ = Lists.reverse (extractTypeApplicationArgs_go typ)
+
+extractTypeApplicationArgs_go :: Core.Type -> [Core.Type]
+extractTypeApplicationArgs_go t =
+    case t of
+      Core.TypeApplication v0 -> Lists.cons (Core.applicationTypeArgument v0) (extractTypeApplicationArgs_go (Core.applicationTypeFunction v0))
+      _ -> []
+
+fieldTypeToFormalParam :: JavaEnvironment.Aliases -> Core.FieldType -> t0 -> Graph.Graph -> Either Errors.Error Syntax.FormalParameter
+fieldTypeToFormalParam aliases ft cx g =
+    Eithers.bind (encodeType aliases Sets.empty (Core.fieldTypeType ft) cx g) (\jt -> Right (Utils.javaTypeToJavaFormalParameter jt (Core.fieldTypeName ft)))
+
+filterByFlags :: [t0] -> [Bool] -> [t0]
+filterByFlags xs flags = Lists.map (\p -> Pairs.first p) (Lists.filter (\p -> Pairs.second p) (Lists.zip xs flags))
+
+filterPhantomTypeArgs :: Core.Name -> [Core.Type] -> t0 -> Graph.Graph -> Either t1 [Core.Type]
+filterPhantomTypeArgs calleeName allTypeArgs cx g =
+    Eithers.bind (Right (Lexical.lookupBinding g calleeName)) (\mel -> Optionals.cases mel (Right allTypeArgs) (\el -> Optionals.cases (Core.bindingTypeScheme el) (Right allTypeArgs) (\ts ->
+      let schemeVars = Lists.filter (\v -> isSimpleName v) (Core.typeSchemeVariables ts)
+          schemeTypeVars = collectTypeVars (Core.typeSchemeBody ts)
+          schemeType = Core.typeSchemeBody ts
+          nParams = countFunctionParams schemeType
+          peeled = peelDomainTypes nParams schemeType
+          calleeDoms = Pairs.first peeled
+          calleeCod = Pairs.second peeled
+          overgenSubst = detectAccumulatorUnification calleeDoms calleeCod schemeVars
+          keepFlags = Lists.map (\v -> Logic.and (Sets.member v schemeTypeVars) (Logic.not (Maps.member v overgenSubst))) schemeVars
+      in (Logic.ifElse (Logic.not (Equality.equal (Lists.length schemeVars) (Lists.length allTypeArgs))) (Right allTypeArgs) (Right (filterPhantomTypeArgs_filterAndApply allTypeArgs keepFlags overgenSubst))))))
+
+filterPhantomTypeArgs_filterAndApply :: [Core.Type] -> [Bool] -> M.Map Core.Name Core.Type -> [Core.Type]
+filterPhantomTypeArgs_filterAndApply allTypeArgs keepFlags overgenSubst =
+
+      let filtered = Lists.map (\p -> Pairs.first p) (Lists.filter (\p -> Pairs.second p) (Lists.zip allTypeArgs keepFlags))
+      in (Logic.ifElse (Logic.not (Maps.null overgenSubst)) (Lists.map (\t -> substituteTypeVarsWithTypes overgenSubst t) filtered) filtered)
+
+findMatchingLambdaVar :: Core.Name -> S.Set Core.Name -> Core.Name
+findMatchingLambdaVar name lambdaVars =
+    Logic.ifElse (Sets.member name lambdaVars) name (Logic.ifElse (isLambdaBoundIn_isQualified name) (Optionals.fromOptional name (Lists.find (\lv -> Logic.and (isLambdaBoundIn_isQualified lv) (Equality.equal (Names.localNameOf lv) (Names.localNameOf name))) (Sets.toList lambdaVars))) (Logic.ifElse (Sets.member (Core.Name (Names.localNameOf name)) lambdaVars) (Core.Name (Names.localNameOf name)) name))
+
+findPairFirst :: Core.Type -> Maybe Core.Name
+findPairFirst t =
+    case (Strip.deannotateType t) of
+      Core.TypePair v0 -> case (Strip.deannotateType (Core.pairTypeFirst v0)) of
+        Core.TypeVariable v1 -> Just v1
+        _ -> Nothing
+      _ -> Nothing
+
+findSelfRefVar :: (Eq t0, Ord t0) => (M.Map t0 [t0] -> Maybe t0)
+findSelfRefVar grouped =
+
+      let selfRefs = Lists.filter (\entry -> Lists.elem (Pairs.first entry) (Pairs.second entry)) (Maps.toList grouped)
+      in (Optionals.map (\entry -> Pairs.first entry) (Lists.maybeHead selfRefs))
+
+first20Primes :: [Integer]
+first20Primes =
+    [
+      2,
+      3,
+      5,
+      7,
+      11,
+      13,
+      17,
+      19,
+      23,
+      29,
+      31,
+      37,
+      41,
+      43,
+      47,
+      53,
+      59,
+      61,
+      67,
+      71]
+
+flattenApps :: Core.Term -> [Core.Term] -> ([Core.Term], Core.Term)
+flattenApps t acc =
+    case (Strip.deannotateTerm t) of
+      Core.TermApplication v0 -> flattenApps (Core.applicationFunction v0) (Lists.cons (Core.applicationArgument v0) acc)
+      _ -> (acc, t)
+
+flattenBindings :: [Core.Binding] -> [Core.Binding]
+flattenBindings bindings =
+    Lists.bind bindings (\b -> case (Strip.deannotateTerm (Core.bindingTerm b)) of
+      Core.TermLet v0 -> Lists.concat2 (flattenBindings (Core.letBindings v0)) [
+        Core.Binding {
+          Core.bindingName = (Core.bindingName b),
+          Core.bindingTerm = (Core.letBody v0),
+          Core.bindingTypeScheme = (Core.bindingTypeScheme b)}]
+      _ -> [
+        b])
+
+freshJavaName :: Core.Name -> S.Set Core.Name -> Core.Name
+freshJavaName base avoid = freshJavaName_go base avoid 2
+
+freshJavaName_go :: Core.Name -> S.Set Core.Name -> Int -> Core.Name
+freshJavaName_go base avoid i =
+
+      let candidate = Core.Name (Strings.cat2 (Core.unName base) (Literals.showInt32 i))
+      in (Logic.ifElse (Sets.member candidate avoid) (freshJavaName_go base avoid (Math.add i 1)) candidate)
+
+functionCall :: JavaEnvironment.JavaEnvironment -> Bool -> Core.Name -> [Core.Term] -> [Core.Type] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+functionCall env isPrim name args typeApps cx g =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+          isLambdaBound = isLambdaBoundIn name (JavaEnvironment.aliasesLambdaVars aliases)
+      in (Eithers.bind (Eithers.mapList (\arg -> encodeTerm env arg cx g) args) (\jargs0 ->
+        let wrapResult = wrapLazyArguments g name jargs0
+            jargs = Pairs.first wrapResult
+            mMethodOverride = Pairs.second wrapResult
+        in (Logic.ifElse (Logic.or (isLocalVariable name) isLambdaBound) (Eithers.bind (encodeVariable env name cx g) (\baseExpr -> Right (Lists.foldl (\acc -> \jarg -> applyJavaArg acc jarg) baseExpr jargs))) (
+          let overrideMethodName =
+                  \jid -> Optionals.cases mMethodOverride jid (\m ->
+                    let s = Syntax.unIdentifier jid
+                    in (Syntax.Identifier (Strings.cat2 (Strings.fromList (Lists.take (Math.sub (Strings.length s) (Strings.length JavaNames.applyMethodName)) (Strings.toList s))) m)))
+          in (Logic.ifElse (Lists.null typeApps) (
+            let header =
+                    Syntax.MethodInvocation_HeaderSimple (Syntax.MethodName (overrideMethodName (elementJavaIdentifier isPrim False aliases name)))
+            in (Right (Utils.javaMethodInvocationToJavaExpression (Syntax.MethodInvocation {
+              Syntax.methodInvocationHeader = header,
+              Syntax.methodInvocationArguments = jargs})))) (
+            let qn = Names.qualifyName name
+                mns = Util.qualifiedNameModuleName qn
+                localName = Util.qualifiedNameLocal qn
+            in (Optionals.cases mns (
+              let header =
+                      Syntax.MethodInvocation_HeaderSimple (Syntax.MethodName (overrideMethodName (elementJavaIdentifier isPrim False aliases name)))
+              in (Right (Utils.javaMethodInvocationToJavaExpression (Syntax.MethodInvocation {
+                Syntax.methodInvocationHeader = header,
+                Syntax.methodInvocationArguments = jargs})))) (\ns_ ->
+              let classId = Utils.nameToJavaName aliases (elementsQualifiedName ns_)
+                  methodId =
+                          Logic.ifElse isPrim (overrideMethodName (Syntax.Identifier (Strings.cat2 (Syntax.unIdentifier (Utils.nameToJavaName aliases (Names.unqualifyName (Util.QualifiedName {
+                            Util.qualifiedNameModuleName = (Just ns_),
+                            Util.qualifiedNameLocal = (Formatting.capitalize localName)})))) (Strings.cat2 "." JavaNames.applyMethodName)))) (Syntax.Identifier (Utils.sanitizeJavaName localName))
+              in (Eithers.bind (Eithers.mapList (\t -> Eithers.bind (encodeType aliases Sets.empty t cx g) (\jt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jt cx) (\rt -> Right (Syntax.TypeArgumentReference rt)))) typeApps) (\jTypeArgs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs classId methodId jTypeArgs jargs))))))))))))
+
+getCodomain :: M.Map Core.Name Core.Term -> t0 -> Graph.Graph -> Either Errors.Error Core.Type
+getCodomain ann cx g = Eithers.map (\ft -> Core.functionTypeCodomain ft) (getFunctionType ann cx g)
+
+getFunctionType :: M.Map Core.Name Core.Term -> t0 -> Graph.Graph -> Either Errors.Error Core.FunctionType
+getFunctionType ann cx g =
+    Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g ann)) (\mt -> Optionals.cases mt (Left (Errors.ErrorOther (Errors.OtherError "type annotation is required for function and elimination terms in Java"))) (\t -> case t of
+      Core.TypeFunction v0 -> Right v0
+      _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "expected function type, got: " (ShowCore.type_ t))))))
+
+groupPairsByFirst :: Ord t0 => ([(t0, t1)] -> M.Map t0 [t1])
+groupPairsByFirst pairs =
+    Lists.foldl (\m -> \p ->
+      let k = Pairs.first p
+          v = Pairs.second p
+      in (Maps.alter (\mv -> Optionals.cases mv (Just [
+        v]) (\vs -> Just (Lists.concat2 vs [
+        v]))) k m)) Maps.empty pairs
+
+hashCodeCompareExpr :: String -> String -> Syntax.Expression
+hashCodeCompareExpr otherVar fname =
+
+      let header =
+              Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantType (Utils.javaTypeName (Syntax.Identifier "Integer"))),
+                Syntax.methodInvocation_ComplexTypeArguments = [],
+                Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier "compare")})
+          thisHashCode =
+                  Utils.javaMethodInvocationToJavaExpression (Syntax.MethodInvocation {
+                    Syntax.methodInvocationHeader = (Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                      Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantExpression (Syntax.ExpressionName {
+                        Syntax.expressionNameQualifier = Nothing,
+                        Syntax.expressionNameIdentifier = (Syntax.Identifier (Utils.sanitizeJavaName fname))})),
+                      Syntax.methodInvocation_ComplexTypeArguments = [],
+                      Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier JavaNames.hashCodeMethodName)})),
+                    Syntax.methodInvocationArguments = []})
+          otherHashCode =
+                  Utils.javaMethodInvocationToJavaExpression (Syntax.MethodInvocation {
+                    Syntax.methodInvocationHeader = (Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                      Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantExpression (Utils.fieldExpression (Utils.javaIdentifier otherVar) (Utils.javaIdentifier fname))),
+                      Syntax.methodInvocation_ComplexTypeArguments = [],
+                      Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier JavaNames.hashCodeMethodName)})),
+                    Syntax.methodInvocationArguments = []})
+      in (Utils.javaMethodInvocationToJavaExpression (Syntax.MethodInvocation {
+        Syntax.methodInvocationHeader = header,
+        Syntax.methodInvocationArguments = [
+          thisHashCode,
+          otherHashCode]}))
+
+hashCodeMultPair :: Integer -> Core.Name -> Syntax.MultiplicativeExpression
+hashCodeMultPair i fname =
+
+      let fnameStr = Core.unName fname
+          lhs =
+                  Syntax.MultiplicativeExpressionUnary (Utils.javaPrimaryToJavaUnaryExpression (Utils.javaLiteralToJavaPrimary (Utils.javaInt i)))
+          rhs =
+                  Utils.javaPostfixExpressionToJavaUnaryExpression (Utils.javaMethodInvocationToJavaPostfixExpression (Syntax.MethodInvocation {
+                    Syntax.methodInvocationHeader = (Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                      Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantType (Utils.javaTypeName (Syntax.Identifier "java.util.Objects"))),
+                      Syntax.methodInvocation_ComplexTypeArguments = [],
+                      Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier JavaNames.hashCodeMethodName)})),
+                    Syntax.methodInvocationArguments = [
+                      Utils.javaExpressionNameToJavaExpression (Syntax.ExpressionName {
+                        Syntax.expressionNameQualifier = Nothing,
+                        Syntax.expressionNameIdentifier = (Syntax.Identifier (Utils.sanitizeJavaName fnameStr))})]}))
+      in (Syntax.MultiplicativeExpressionTimes (Syntax.MultiplicativeExpression_Binary {
+        Syntax.multiplicativeExpression_BinaryLhs = lhs,
+        Syntax.multiplicativeExpression_BinaryRhs = rhs}))
+
+innerClassRef :: JavaEnvironment.Aliases -> Core.Name -> String -> Syntax.Identifier
+innerClassRef aliases name local =
+
+      let id = Syntax.unIdentifier (Utils.nameToJavaName aliases name)
+      in (Syntax.Identifier (Strings.cat2 (Strings.cat2 id ".") local))
+
+insertBranchVar :: Core.Name -> JavaEnvironment.JavaEnvironment -> JavaEnvironment.JavaEnvironment
+insertBranchVar name env =
+
+      let aliases = JavaEnvironment.javaEnvironmentAliases env
+      in JavaEnvironment.JavaEnvironment {
+        JavaEnvironment.javaEnvironmentAliases = JavaEnvironment.Aliases {
+          JavaEnvironment.aliasesCurrentNamespace = (JavaEnvironment.aliasesCurrentNamespace aliases),
+          JavaEnvironment.aliasesPackages = (JavaEnvironment.aliasesPackages aliases),
+          JavaEnvironment.aliasesBranchVars = (Sets.insert name (JavaEnvironment.aliasesBranchVars aliases)),
+          JavaEnvironment.aliasesRecursiveVars = (JavaEnvironment.aliasesRecursiveVars aliases),
+          JavaEnvironment.aliasesInScopeTypeParams = (JavaEnvironment.aliasesInScopeTypeParams aliases),
+          JavaEnvironment.aliasesPolymorphicLocals = (JavaEnvironment.aliasesPolymorphicLocals aliases),
+          JavaEnvironment.aliasesInScopeJavaVars = (JavaEnvironment.aliasesInScopeJavaVars aliases),
+          JavaEnvironment.aliasesVarRenames = (JavaEnvironment.aliasesVarRenames aliases),
+          JavaEnvironment.aliasesLambdaVars = (JavaEnvironment.aliasesLambdaVars aliases),
+          JavaEnvironment.aliasesTypeVarSubst = (JavaEnvironment.aliasesTypeVarSubst aliases),
+          JavaEnvironment.aliasesTrustedTypeVars = (JavaEnvironment.aliasesTrustedTypeVars aliases),
+          JavaEnvironment.aliasesMethodCodomain = Nothing,
+          JavaEnvironment.aliasesThunkedVars = (JavaEnvironment.aliasesThunkedVars aliases)},
+        JavaEnvironment.javaEnvironmentGraph = (JavaEnvironment.javaEnvironmentGraph env)}
+
+interfaceTypes :: Bool -> JavaEnvironment.Aliases -> [Syntax.TypeParameter] -> Core.Name -> [Syntax.InterfaceType]
+interfaceTypes isSer aliases tparams elName =
+
+      let javaSerializableType =
+              Syntax.InterfaceType (Syntax.ClassType {
+                Syntax.classTypeAnnotations = [],
+                Syntax.classTypeQualifier = Syntax.ClassTypeQualifierNone,
+                Syntax.classTypeIdentifier = (Utils.javaTypeIdentifier "Serializable"),
+                Syntax.classTypeArguments = []})
+          selfTypeArg =
+                  Syntax.TypeArgumentReference (Utils.nameToJavaReferenceType aliases False (Lists.map (\tp_ -> Utils.typeParameterToTypeArgument tp_) tparams) elName Nothing)
+          javaComparableType =
+                  Syntax.InterfaceType (Syntax.ClassType {
+                    Syntax.classTypeAnnotations = [],
+                    Syntax.classTypeQualifier = Syntax.ClassTypeQualifierNone,
+                    Syntax.classTypeIdentifier = (Utils.javaTypeIdentifier "Comparable"),
+                    Syntax.classTypeArguments = [
+                      selfTypeArg]})
+      in (Logic.ifElse isSer [
+        javaSerializableType,
+        javaComparableType] [])
+
+isBigNumericType :: Core.Type -> Bool
+isBigNumericType typ =
+    case (Strip.deannotateType typ) of
+      Core.TypeLiteral v0 -> case v0 of
+        Core.LiteralTypeDecimal -> True
+        Core.LiteralTypeInteger v1 -> case v1 of
+          Core.IntegerTypeBigint -> True
+          _ -> False
+        _ -> False
+      _ -> False
+
+isBinaryType :: Core.Type -> Bool
+isBinaryType typ =
+    case (Strip.deannotateType typ) of
+      Core.TypeLiteral v0 -> case v0 of
+        Core.LiteralTypeBinary -> True
+        _ -> False
+      _ -> False
+
+isFieldUnitType :: Core.Name -> Core.Name -> t0 -> Graph.Graph -> Either t1 Bool
+isFieldUnitType typeName fieldName cx g =
+
+      let schemaTypes = Graph.graphSchemaTypes g
+      in (Optionals.cases (Maps.lookup typeName schemaTypes) (Right False) (\ts -> case (Strip.deannotateType (Core.typeSchemeBody ts)) of
+        Core.TypeUnion v0 -> Right (Optionals.cases (Lists.find (\ft -> Equality.equal (Core.fieldTypeName ft) fieldName) v0) False (\ft -> Predicates.isUnitType (Strip.deannotateType (Core.fieldTypeType ft))))
+        _ -> Right False))
+
+isLambdaBoundIn :: Core.Name -> S.Set Core.Name -> Bool
+isLambdaBoundIn name lambdaVars =
+    Logic.or (Sets.member name lambdaVars) (Logic.or (Logic.and (isLambdaBoundIn_isQualified name) (Optionals.isGiven (Lists.find (\lv -> Logic.and (isLambdaBoundIn_isQualified lv) (Equality.equal (Names.localNameOf lv) (Names.localNameOf name))) (Sets.toList lambdaVars)))) (Logic.and (Logic.not (isLambdaBoundIn_isQualified name)) (Sets.member (Core.Name (Names.localNameOf name)) lambdaVars)))
+
+isLambdaBoundIn_isQualified :: Core.Name -> Bool
+isLambdaBoundIn_isQualified n = Optionals.isGiven (Util.qualifiedNameModuleName (Names.qualifyName n))
+
+isLambdaBoundVariable :: Core.Name -> Bool
+isLambdaBoundVariable name =
+
+      let v = Core.unName name
+      in (Equality.lte (Strings.length v) 4)
+
+isLocalVariable :: Core.Name -> Bool
+isLocalVariable name = Optionals.isNone (Util.qualifiedNameModuleName (Names.qualifyName name))
+
+isNonComparableType :: Core.Type -> Bool
+isNonComparableType typ =
+    case (Strip.deannotateType typ) of
+      Core.TypeEither _ -> True
+      Core.TypeFunction _ -> True
+      Core.TypeUnit -> True
+      Core.TypeLiteral v0 -> case v0 of
+        Core.LiteralTypeBinary -> True
+        _ -> False
+      Core.TypeForall v0 -> isNonComparableType (Core.forallTypeBody v0)
+      _ -> False
+
+isRecursiveVariable :: JavaEnvironment.Aliases -> Core.Name -> Bool
+isRecursiveVariable aliases name = Sets.member name (JavaEnvironment.aliasesRecursiveVars aliases)
+
+isSerializableJavaType :: Core.Type -> Bool
+isSerializableJavaType typ = Predicates.isNominalType typ
+
+isSimpleName :: Core.Name -> Bool
+isSimpleName name = Equality.equal (Lists.length (Strings.splitOn "." (Core.unName name))) 1
+
+isUnresolvedInferenceVar :: Core.Name -> Bool
+isUnresolvedInferenceVar name =
+
+      let chars = Strings.toList (Core.unName name)
+      in (Optionals.fromOptional False (Optionals.map (\p ->
+        let firstCh = Pairs.first p
+            rest = Pairs.second p
+        in (Logic.ifElse (Logic.not (Equality.equal firstCh 116)) False (Logic.and (Logic.not (Lists.null rest)) (Lists.null (Lists.filter (\c -> Logic.not (isUnresolvedInferenceVar_isDigit c)) rest))))) (Lists.uncons chars)))
+
+isUnresolvedInferenceVar_isDigit :: Int -> Bool
+isUnresolvedInferenceVar_isDigit c = Logic.and (Equality.gte c 48) (Equality.lte c 57)
+
+java11Features :: JavaEnvironment.JavaFeatures
+java11Features = JavaEnvironment.JavaFeatures {
+  JavaEnvironment.javaFeaturesSupportsDiamondOperator = True}
+
+java8Features :: JavaEnvironment.JavaFeatures
+java8Features = JavaEnvironment.JavaFeatures {
+  JavaEnvironment.javaFeaturesSupportsDiamondOperator = False}
+
+javaComparableRefType :: Syntax.ReferenceType
+javaComparableRefType =
+    Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeClass (Syntax.ClassType {
+      Syntax.classTypeAnnotations = [],
+      Syntax.classTypeQualifier = Syntax.ClassTypeQualifierNone,
+      Syntax.classTypeIdentifier = (Utils.javaTypeIdentifier "Comparable"),
+      Syntax.classTypeArguments = []}))
+
+javaEnvGetGraph :: JavaEnvironment.JavaEnvironment -> Graph.Graph
+javaEnvGetGraph env = JavaEnvironment.javaEnvironmentGraph env
+
+javaEnvSetGraph :: Graph.Graph -> JavaEnvironment.JavaEnvironment -> JavaEnvironment.JavaEnvironment
+javaEnvSetGraph g env =
+    JavaEnvironment.JavaEnvironment {
+      JavaEnvironment.javaEnvironmentAliases = (JavaEnvironment.javaEnvironmentAliases env),
+      JavaEnvironment.javaEnvironmentGraph = g}
+
+javaFeatures :: JavaEnvironment.JavaFeatures
+javaFeatures = java11Features
+
+javaIdentifierToString :: Syntax.Identifier -> String
+javaIdentifierToString id = Syntax.unIdentifier id
+
+javaTypeArgumentsForNamedType :: Core.Name -> t0 -> Graph.Graph -> Either Errors.Error [Syntax.TypeArgument]
+javaTypeArgumentsForNamedType tname cx g =
+    Eithers.bind (Resolution.requireType cx g tname) (\typ -> Right (Lists.map (\tp_ -> Utils.typeParameterToTypeArgument tp_) (javaTypeParametersForType typ)))
+
+javaTypeArgumentsForType :: Core.Type -> [Syntax.TypeArgument]
+javaTypeArgumentsForType typ = Lists.reverse (Lists.map Utils.typeParameterToTypeArgument (javaTypeParametersForType typ))
+
+javaTypeParametersForType :: Core.Type -> [Syntax.TypeParameter]
+javaTypeParametersForType typ =
+
+      let toParam = \name -> Utils.javaTypeParameter (Formatting.capitalize (Core.unName name))
+          boundVars = javaTypeParametersForType_bvars typ
+          freeVars = Lists.filter (\v -> isLambdaBoundVariable v) (Sets.toList (Variables.freeVariablesInType typ))
+          vars = Lists.nub (Lists.concat2 boundVars freeVars)
+      in (Lists.map toParam vars)
+
+javaTypeParametersForType_bvars :: Core.Type -> [Core.Name]
+javaTypeParametersForType_bvars t =
+    case t of
+      Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (javaTypeParametersForType_bvars (Core.forallTypeBody v0))
+      _ -> []
+
+lazyFlagsForPrimitive :: Graph.Graph -> Core.Name -> [Bool]
+lazyFlagsForPrimitive g name =
+    Optionals.cases (Maps.lookup name (Graph.graphPrimitives g)) [] (\prim -> Lists.map (\p -> Typing.parameterIsLazy p) (Typing.termSignatureParameters (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim))))
+
+moduleToJava :: Packaging.Module -> [Packaging.Definition] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error (M.Map String String)
+moduleToJava mod defs cx g =
+    Eithers.bind (encodeDefinitions mod defs cx g) (\units -> Right (Maps.fromList (Lists.map (\entry ->
+      let name = Pairs.first entry
+          unit = Pairs.second entry
+      in (bindingNameToFilePath name, (Serialization.printExpr (Serialization.parenthesize (Serde.compilationUnitToExpr unit))))) (Maps.toList units))))
+
+nameMapToTypeMap :: Ord t0 => (M.Map t0 Core.Name -> M.Map t0 Core.Type)
+nameMapToTypeMap m = Maps.map (\v -> Core.TypeVariable v) m
+
+namespaceParent :: Packaging.ModuleName -> Maybe Packaging.ModuleName
+namespaceParent ns =
+
+      let parts = Strings.splitOn "." (Packaging.unModuleName ns)
+          initParts = Optionals.fromOptional [] (Lists.maybeInit parts)
+      in (Logic.ifElse (Lists.null initParts) Nothing (Just (Packaging.ModuleName (Strings.intercalate "." initParts))))
+
+noComment :: Syntax.ClassBodyDeclaration -> Syntax.ClassBodyDeclarationWithComments
+noComment decl =
+    Syntax.ClassBodyDeclarationWithComments {
+      Syntax.classBodyDeclarationWithCommentsValue = decl,
+      Syntax.classBodyDeclarationWithCommentsComments = Nothing}
+
+noInterfaceComment :: Syntax.InterfaceMemberDeclaration -> Syntax.InterfaceMemberDeclarationWithComments
+noInterfaceComment decl =
+    Syntax.InterfaceMemberDeclarationWithComments {
+      Syntax.interfaceMemberDeclarationWithCommentsValue = decl,
+      Syntax.interfaceMemberDeclarationWithCommentsComments = Nothing}
+
+otherwiseBranch :: JavaEnvironment.JavaEnvironment -> JavaEnvironment.Aliases -> Core.Type -> Core.Type -> Core.Name -> Syntax.Type -> [Syntax.TypeArgument] -> Core.Term -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclarationWithComments
+otherwiseBranch env aliases dom cod tname jcod targs d cx g =
+
+      let jdom = Syntax.TypeReference (Utils.nameToJavaReferenceType aliases True targs tname Nothing)
+          mods = [
+                Syntax.MethodModifierPublic]
+          anns = [
+                Utils.overrideAnnotation]
+          param = Utils.javaTypeToJavaFormalParameter jdom (Core.Name "instance")
+          result = Syntax.ResultType (Syntax.UnannType jcod)
+      in (Eithers.bind (analyzeJavaFunction env d cx g) (\fs ->
+        let bindings = Typing.functionStructureBindings fs
+            rawBody = Typing.functionStructureBody fs
+            innerBody = annotateBodyWithCod cod rawBody
+            env2 = Typing.functionStructureEnvironment fs
+        in (Eithers.bind (bindingsToStatements env2 bindings cx g) (\bindResult ->
+          let bindingStmts = Pairs.first bindResult
+              env3 = Pairs.second bindResult
+          in (Eithers.bind (encodeTerm env3 innerBody cx g) (\jret ->
+            let returnStmt = Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just jret))
+                allStmts = Lists.concat2 bindingStmts [
+                      returnStmt]
+            in (Right (noComment (Utils.methodDeclaration mods [] anns JavaNames.otherwiseMethodName [
+              param] result (Just allStmts))))))))))
+
+peelDomainTypes :: Int -> Core.Type -> ([Core.Type], Core.Type)
+peelDomainTypes n t =
+    Logic.ifElse (Equality.lte n 0) ([], t) (case (Strip.deannotateType t) of
+      Core.TypeFunction v0 ->
+        let rest = peelDomainTypes (Math.sub n 1) (Core.functionTypeCodomain v0)
+        in (Lists.cons (Core.functionTypeDomain v0) (Pairs.first rest), (Pairs.second rest))
+      _ -> ([], t))
+
+peelDomainsAndCod :: Int -> Core.Type -> ([Core.Type], Core.Type)
+peelDomainsAndCod n t =
+    Logic.ifElse (Equality.lte n 0) ([], t) (case (Strip.deannotateType t) of
+      Core.TypeFunction v0 ->
+        let rest = peelDomainsAndCod (Math.sub n 1) (Core.functionTypeCodomain v0)
+        in (Lists.cons (Core.functionTypeDomain v0) (Pairs.first rest), (Pairs.second rest))
+      _ -> ([], t))
+
+peelExpectedTypes :: M.Map Core.Name Core.Type -> Int -> Core.Type -> [Core.Type]
+peelExpectedTypes subst n t =
+    Logic.ifElse (Equality.equal n 0) [] (case (Strip.deannotateType t) of
+      Core.TypeFunction v0 -> Lists.cons (applySubstFull subst (Core.functionTypeDomain v0)) (peelExpectedTypes subst (Math.sub n 1) (Core.functionTypeCodomain v0))
+      _ -> [])
+
+propagateType :: Core.Type -> Core.Term -> Core.Term
+propagateType typ term =
+
+      let setTypeAnn = \t -> Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ typ)) t
+      in case (Strip.deannotateTerm term) of
+        Core.TermLambda _ ->
+          let annotated = setTypeAnn term
+          in case (Strip.deannotateType typ) of
+            Core.TypeFunction v1 -> propagateType_propagateIntoLambda (Core.functionTypeCodomain v1) annotated
+            _ -> annotated
+        Core.TermLet v0 ->
+          let propagatedBindings =
+                  Lists.map (\b -> Optionals.cases (Core.bindingTypeScheme b) b (\ts -> Core.Binding {
+                    Core.bindingName = (Core.bindingName b),
+                    Core.bindingTerm = (propagateType (Core.typeSchemeBody ts) (Core.bindingTerm b)),
+                    Core.bindingTypeScheme = (Core.bindingTypeScheme b)})) (Core.letBindings v0)
+          in (setTypeAnn (propagateType_rebuildLet term propagatedBindings (propagateType typ (Core.letBody v0))))
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+              annotatedFun =
+                      case (Strip.deannotateTerm fun) of
+                        Core.TermCases v1 ->
+                          let dom = Resolution.nominalApplication (Core.caseStatementTypeName v1) []
+                              ft =
+                                      Core.TypeFunction (Core.FunctionType {
+                                        Core.functionTypeDomain = dom,
+                                        Core.functionTypeCodomain = typ})
+                          in (Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ ft)) fun)
+                        _ -> fun
+          in (setTypeAnn (Core.TermApplication (Core.Application {
+            Core.applicationFunction = annotatedFun,
+            Core.applicationArgument = arg})))
+        _ -> setTypeAnn term
+
+propagateType_propagateIntoLambda :: Core.Type -> Core.Term -> Core.Term
+propagateType_propagateIntoLambda cod t =
+    case t of
+      Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {
+        Core.annotatedTermBody = (propagateType_propagateIntoLambda cod (Core.annotatedTermBody v0)),
+        Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})
+      Core.TermLambda v0 -> Core.TermLambda (Core.Lambda {
+        Core.lambdaParameter = (Core.lambdaParameter v0),
+        Core.lambdaDomain = (Core.lambdaDomain v0),
+        Core.lambdaBody = (propagateType cod (Core.lambdaBody v0))})
+      _ -> t
+
+propagateType_rebuildLet :: Core.Term -> [Core.Binding] -> Core.Term -> Core.Term
+propagateType_rebuildLet t bindings newBody =
+    case t of
+      Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {
+        Core.annotatedTermBody = (propagateType_rebuildLet (Core.annotatedTermBody v0) bindings newBody),
+        Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})
+      Core.TermLet _ -> Core.TermLet (Core.Let {
+        Core.letBindings = bindings,
+        Core.letBody = newBody})
+      _ -> t
+
+propagateTypesInAppChain :: Core.Type -> Core.Type -> Core.Term -> Core.Term
+propagateTypesInAppChain fixedCod resultType t =
+
+      let flattened = flattenApps t []
+          args = Pairs.first flattened
+          fun = Pairs.second flattened
+          lambdaDomsResult = collectLambdaDomains fun
+          lambdaDoms = Pairs.first lambdaDomsResult
+          nArgs = Lists.length args
+          nLambdaDoms = Lists.length lambdaDoms
+      in (Logic.ifElse (Logic.and (Equality.gt nLambdaDoms 0) (Equality.gt nArgs 0)) (
+        let bodyRetType = Pairs.second (peelDomainsAndCod (Math.sub nLambdaDoms nArgs) resultType)
+            funType =
+                    Lists.foldl (\c -> \d -> Core.TypeFunction (Core.FunctionType {
+                      Core.functionTypeDomain = d,
+                      Core.functionTypeCodomain = c})) bodyRetType (Lists.reverse lambdaDoms)
+            annotatedFun = Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ funType)) fun
+        in (rebuildApps annotatedFun args funType)) (case (Strip.deannotateTerm t) of
+        Core.TermApplication v0 ->
+          let lhs = Core.applicationFunction v0
+              rhs = Core.applicationArgument v0
+              annotatedLhs =
+                      case (Strip.deannotateTerm lhs) of
+                        Core.TermCases v1 ->
+                          let dom = Resolution.nominalApplication (Core.caseStatementTypeName v1) []
+                              ft =
+                                      Core.TypeFunction (Core.FunctionType {
+                                        Core.functionTypeDomain = dom,
+                                        Core.functionTypeCodomain = fixedCod})
+                          in (Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ ft)) lhs)
+                        _ -> lhs
+          in (Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ resultType)) (Core.TermApplication (Core.Application {
+            Core.applicationFunction = annotatedLhs,
+            Core.applicationArgument = rhs})))
+        _ -> Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ resultType)) t))
+
+rebuildApps :: Core.Term -> [Core.Term] -> Core.Type -> Core.Term
+rebuildApps f args fType =
+    Logic.ifElse (Lists.null args) f (case (Strip.deannotateType fType) of
+      Core.TypeFunction v0 -> Optionals.fromOptional f (Optionals.map (\p ->
+        let arg = Pairs.first p
+            rest = Pairs.second p
+            remainingType = Core.functionTypeCodomain v0
+            app =
+                    Core.TermApplication (Core.Application {
+                      Core.applicationFunction = f,
+                      Core.applicationArgument = arg})
+            annotatedApp = Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ remainingType)) app
+        in (rebuildApps annotatedApp rest remainingType)) (Lists.uncons args))
+      _ -> Lists.foldl (\acc -> \a -> Core.TermApplication (Core.Application {
+        Core.applicationFunction = acc,
+        Core.applicationArgument = a})) f args)
+
+recordBuilderClass :: JavaEnvironment.Aliases -> [Syntax.TypeParameter] -> Core.Name -> [Core.FieldType] -> t0 -> Graph.Graph -> Either Errors.Error [Syntax.ClassBodyDeclarationWithComments]
+recordBuilderClass aliases tparams elName fields cx g =
+
+      let typeArgRefs = Lists.map Utils.typeParameterToReferenceType tparams
+          typeArgs = Lists.map (\rt -> Syntax.TypeArgumentReference rt) typeArgRefs
+          mTypeArgs = Logic.ifElse (Lists.null tparams) Nothing (Just (Syntax.TypeArgumentsOrDiamondArguments typeArgs))
+          recordLocalName = Utils.sanitizeJavaName (Names.localNameOf elName)
+          builderType = Utils.javaRefType typeArgRefs Nothing "Builder"
+          builderResult = Utils.javaTypeToJavaResult builderType
+          recordType = Utils.javaRefType typeArgRefs Nothing recordLocalName
+          recordResult = Utils.javaTypeToJavaResult recordType
+          returnThisStmt = Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just Utils.javaThis))
+      in (Eithers.bind (Eithers.mapList (\f ->
+        let mods = [
+              Syntax.FieldModifierPrivate]
+            ftype = Core.fieldTypeType f
+            fname = Core.fieldTypeName f
+        in (Eithers.bind (encodeType aliases Sets.empty ftype cx g) (\jt -> Right (noComment (Utils.javaMemberField mods jt (Utils.fieldNameToJavaVariableDeclarator fname)))))) fields) (\builderFields -> Eithers.bind (Eithers.mapList (\f ->
+        let mods = [
+              Syntax.MethodModifierPublic]
+            fname = Core.fieldTypeName f
+            assignStmt = Syntax.BlockStatementStatement (Utils.toAssignStmt fname)
+        in (Eithers.bind (fieldTypeToFormalParam aliases f cx g) (\param -> Right (noComment (Utils.methodDeclaration mods [] [] (builderSetterName fname) [
+          param] builderResult (Just [
+          assignStmt,
+          returnThisStmt])))))) fields) (\setterMethods ->
+        let buildMods = [
+              Syntax.MethodModifierPublic]
+            buildArgs = Lists.map (\f -> Utils.fieldNameToJavaExpression (Core.fieldTypeName f)) fields
+            buildReturnStmt =
+                    Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (Utils.javaConstructorCall (Utils.javaConstructorName (Syntax.Identifier recordLocalName) mTypeArgs) buildArgs Nothing)))
+            buildMethod =
+                    withCommentString (Strings.cat2 "Builds an immutable {@link " (Strings.cat2 recordLocalName "}.")) (Utils.methodDeclaration buildMods [] [] "build" [] recordResult (Just [
+                      buildReturnStmt]))
+            builderClassDecl =
+                    Utils.javaClassDeclaration aliases tparams (Core.Name "Builder") [
+                      Syntax.ClassModifierPublic,
+                      Syntax.ClassModifierStatic,
+                      Syntax.ClassModifierFinal] Nothing [] (Lists.concat [
+                      builderFields,
+                      setterMethods,
+                      [
+                        buildMethod]])
+            builderClassMember =
+                    withCommentString (Strings.cat2 "A fluent builder for {@link " (Strings.cat2 recordLocalName "}.")) (Syntax.ClassBodyDeclarationClassMember (Syntax.ClassMemberDeclarationClass builderClassDecl))
+            factoryMods =
+                    [
+                      Syntax.MethodModifierPublic,
+                      Syntax.MethodModifierStatic]
+            factoryReturnStmt =
+                    Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (Utils.javaConstructorCall (Utils.javaConstructorName (Syntax.Identifier "Builder") mTypeArgs) [] Nothing)))
+            factoryMethod =
+                    withCommentString (Strings.cat2 "Creates a new fluent builder for {@link " (Strings.cat2 recordLocalName "}.")) (Utils.methodDeclaration factoryMods tparams [] "builder" [] builderResult (Just [
+                      factoryReturnStmt]))
+        in (Right [
+          factoryMethod,
+          builderClassMember]))))
+
+recordCompareToMethod :: JavaEnvironment.Aliases -> t0 -> Core.Name -> [Core.FieldType] -> Syntax.ClassBodyDeclaration
+recordCompareToMethod aliases tparams elName fields =
+
+      let anns =
+              [
+                Utils.overrideAnnotation,
+                Utils.suppressWarningsUncheckedAnnotation]
+          mods = [
+                Syntax.MethodModifierPublic]
+          param =
+                  Utils.javaTypeToJavaFormalParameter (Utils.javaTypeFromTypeName aliases elName) (Core.Name JavaNames.otherInstanceName)
+          result = Utils.javaTypeToJavaResult Utils.javaIntType
+      in (Utils.methodDeclaration mods [] anns JavaNames.compareToMethodName [
+        param] result (Just (compareToBody aliases JavaNames.otherInstanceName fields)))
+
+recordConstructor :: JavaEnvironment.Aliases -> Core.Name -> [Core.FieldType] -> t0 -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclaration
+recordConstructor aliases elName fields cx g =
+
+      let assignStmts = Lists.map (\f -> Syntax.BlockStatementStatement (Utils.toAssignStmt (Core.fieldTypeName f))) fields
+      in (Eithers.bind (Eithers.mapList (\f -> fieldTypeToFormalParam aliases f cx g) fields) (\params -> Right (Utils.makeConstructor aliases elName False params assignStmts)))
+
+recordEqualsMethod :: JavaEnvironment.Aliases -> Core.Name -> [Core.FieldType] -> Syntax.ClassBodyDeclaration
+recordEqualsMethod aliases elName fields =
+
+      let anns = [
+            Utils.overrideAnnotation]
+          mods = [
+                Syntax.MethodModifierPublic]
+          param = Utils.javaTypeToJavaFormalParameter (Utils.javaRefType [] Nothing "Object") (Core.Name JavaNames.otherInstanceName)
+          result = Utils.javaTypeToJavaResult Utils.javaBooleanType
+          tmpName = "o"
+          instanceOfStmt =
+                  Syntax.BlockStatementStatement (Syntax.StatementIfThen (Syntax.IfThenStatement {
+                    Syntax.ifThenStatementExpression = (Utils.javaUnaryExpressionToJavaExpression (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusNot (Utils.javaRelationalExpressionToJavaUnaryExpression (Utils.javaInstanceOf (Utils.javaIdentifierToJavaRelationalExpression (Utils.javaIdentifier JavaNames.otherInstanceName)) (Utils.nameToJavaReferenceType aliases False [] elName Nothing)))))),
+                    Syntax.ifThenStatementStatement = (Utils.javaReturnStatement (Just (Utils.javaBooleanExpression False)))}))
+          castStmt =
+                  Utils.variableDeclarationStatement aliases (Utils.javaTypeFromTypeName aliases elName) (Utils.javaIdentifier tmpName) (Utils.javaCastExpressionToJavaExpression (Utils.javaCastExpression (Utils.nameToJavaReferenceType aliases False [] elName Nothing) (Utils.javaIdentifierToJavaUnaryExpression (Syntax.Identifier (Utils.sanitizeJavaName JavaNames.otherInstanceName)))))
+          returnAllFieldsEqual =
+                  Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (Logic.ifElse (Lists.null fields) (Utils.javaBooleanExpression True) (Utils.javaConditionalAndExpressionToJavaExpression (Syntax.ConditionalAndExpression (Lists.map (\f -> eqClause tmpName f) fields))))))
+      in (Utils.methodDeclaration mods [] anns JavaNames.equalsMethodName [
+        param] result (Just [
+        instanceOfStmt,
+        castStmt,
+        returnAllFieldsEqual]))
+
+recordHashCodeMethod :: [Core.FieldType] -> Syntax.ClassBodyDeclaration
+recordHashCodeMethod fields =
+
+      let anns = [
+            Utils.overrideAnnotation]
+          mods = [
+                Syntax.MethodModifierPublic]
+          result = Utils.javaTypeToJavaResult Utils.javaIntType
+          returnSum =
+                  Syntax.BlockStatementStatement (Logic.ifElse (Lists.null fields) (Utils.javaReturnStatement (Just (Utils.javaIntExpression 0))) (Utils.javaReturnStatement (Just (Utils.javaAdditiveExpressionToJavaExpression (Utils.addExpressions (Lists.zipWith hashCodeMultPair first20Primes (Lists.map (\f -> Core.fieldTypeName f) fields)))))))
+      in (Utils.methodDeclaration mods [] anns JavaNames.hashCodeMethodName [] result (Just [
+        returnSum]))
+
+recordMemberVar :: JavaEnvironment.Aliases -> Core.FieldType -> t0 -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclaration
+recordMemberVar aliases ft cx g =
+
+      let mods =
+              [
+                Syntax.FieldModifierPublic,
+                Syntax.FieldModifierFinal]
+          fname = Core.fieldTypeName ft
+          ftype = Core.fieldTypeType ft
+      in (Eithers.bind (encodeType aliases Sets.empty ftype cx g) (\jt -> Right (Utils.javaMemberField mods jt (Utils.fieldNameToJavaVariableDeclarator fname))))
+
+recordWithMethod :: JavaEnvironment.Aliases -> Core.Name -> [Core.FieldType] -> Core.FieldType -> t0 -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclaration
+recordWithMethod aliases elName fields field cx g =
+
+      let mods = [
+            Syntax.MethodModifierPublic]
+          anns = []
+          methodName =
+                  Strings.cat2 "with" (Formatting.nonAlnumToUnderscores (Formatting.capitalize (Core.unName (Core.fieldTypeName field))))
+          result = Utils.referenceTypeToResult (Utils.nameToJavaReferenceType aliases False [] elName Nothing)
+          consId = Syntax.Identifier (Utils.sanitizeJavaName (Names.localNameOf elName))
+          fieldArgs = Lists.map (\f -> Utils.fieldNameToJavaExpression (Core.fieldTypeName f)) fields
+          returnStmt =
+                  Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (Utils.javaConstructorCall (Utils.javaConstructorName consId Nothing) fieldArgs Nothing)))
+      in (Eithers.bind (fieldTypeToFormalParam aliases field cx g) (\param -> Right (Utils.methodDeclaration mods [] anns methodName [
+        param] result (Just [
+        returnStmt]))))
+
+resolveTypeApps :: [Core.Name] -> [Core.Type] -> M.Map Core.Name Core.Type -> [Core.Type]
+resolveTypeApps schemeVars fallbackTypeApps argSubst =
+
+      let resolvedVars = Sets.fromList (Maps.keys argSubst)
+          unresolvedVars = Lists.filter (\v -> Logic.not (Sets.member v resolvedVars)) schemeVars
+          usedTypes = Sets.fromList (Maps.elems argSubst)
+          unusedIrTypes = Lists.filter (\t -> Logic.not (Sets.member t usedTypes)) fallbackTypeApps
+          remainingSubst = Maps.fromList (Lists.zip unresolvedVars unusedIrTypes)
+          fullSubst = Maps.union argSubst remainingSubst
+      in (Lists.map (\v -> Maps.findWithDefault (Core.TypeVariable v) v fullSubst) schemeVars)
+
+selfRefSubstitution :: (Eq t0, Ord t0) => (M.Map t0 [t0] -> M.Map t0 t0)
+selfRefSubstitution grouped =
+    Lists.foldl (\subst -> \entry -> selfRefSubstitution_processGroup subst (Pairs.first entry) (Pairs.second entry)) Maps.empty (Maps.toList grouped)
+
+selfRefSubstitution_processGroup :: (Eq t0, Ord t0) => (M.Map t0 t0 -> t0 -> [t0] -> M.Map t0 t0)
+selfRefSubstitution_processGroup subst inVar outVars =
+    Logic.ifElse (Lists.elem inVar outVars) (Lists.foldl (\s -> \v -> Logic.ifElse (Equality.equal v inVar) s (Maps.insert v inVar s)) subst outVars) subst
+
+serializableTypes :: Bool -> [Syntax.InterfaceType]
+serializableTypes isSer =
+
+      let javaSerializableType =
+              Syntax.InterfaceType (Syntax.ClassType {
+                Syntax.classTypeAnnotations = [],
+                Syntax.classTypeQualifier = Syntax.ClassTypeQualifierNone,
+                Syntax.classTypeIdentifier = (Utils.javaTypeIdentifier "Serializable"),
+                Syntax.classTypeArguments = []})
+      in (Logic.ifElse isSer [
+        javaSerializableType] [])
+
+splitConstantInitializer :: Syntax.InterfaceMemberDeclaration -> [Syntax.InterfaceMemberDeclaration]
+splitConstantInitializer member =
+    case member of
+      Syntax.InterfaceMemberDeclarationConstant v0 -> Lists.bind (Syntax.constantDeclarationVariables v0) (splitConstantInitializer_splitVar (Syntax.constantDeclarationModifiers v0) (Syntax.constantDeclarationType v0))
+      _ -> [
+        member]
+
+splitConstantInitializer_splitVar :: [Syntax.ConstantModifier] -> Syntax.UnannType -> Syntax.VariableDeclarator -> [Syntax.InterfaceMemberDeclaration]
+splitConstantInitializer_splitVar mods utype vd =
+
+      let vid = Syntax.variableDeclaratorId vd
+          mInit = Syntax.variableDeclaratorInitializer vd
+      in (Optionals.cases mInit [
+        Syntax.InterfaceMemberDeclarationConstant (Syntax.ConstantDeclaration {
+          Syntax.constantDeclarationModifiers = mods,
+          Syntax.constantDeclarationType = utype,
+          Syntax.constantDeclarationVariables = [
+            vd]})] (\init_ -> case init_ of
+        Syntax.VariableInitializerExpression v0 ->
+          let varName = javaIdentifierToString (Syntax.variableDeclaratorIdIdentifier vid)
+              helperName = Strings.cat2 "_init_" varName
+              callExpr = Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocation Nothing (Syntax.Identifier helperName) [])
+              field =
+                      Syntax.InterfaceMemberDeclarationConstant (Syntax.ConstantDeclaration {
+                        Syntax.constantDeclarationModifiers = mods,
+                        Syntax.constantDeclarationType = utype,
+                        Syntax.constantDeclarationVariables = [
+                          Syntax.VariableDeclarator {
+                            Syntax.variableDeclaratorId = vid,
+                            Syntax.variableDeclaratorInitializer = (Just (Syntax.VariableInitializerExpression callExpr))}]})
+              returnSt = Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just v0))
+              resultType = Syntax.ResultType utype
+              helper =
+                      Utils.interfaceMethodDeclaration [
+                        Syntax.InterfaceMethodModifierStatic,
+                        Syntax.InterfaceMethodModifierPrivate] [] helperName [] resultType (Just [
+                        returnSt])
+          in [
+            field,
+            helper]
+        _ -> [
+          Syntax.InterfaceMemberDeclarationConstant (Syntax.ConstantDeclaration {
+            Syntax.constantDeclarationModifiers = mods,
+            Syntax.constantDeclarationType = utype,
+            Syntax.constantDeclarationVariables = [
+              vd]})]))
+
+stripForalls :: Core.Type -> Core.Type
+stripForalls t =
+    case (Strip.deannotateType t) of
+      Core.TypeForall v0 -> stripForalls (Core.forallTypeBody v0)
+      _ -> t
+
+substituteTypeVarsWithTypes :: M.Map Core.Name Core.Type -> Core.Type -> Core.Type
+substituteTypeVarsWithTypes subst t = substituteTypeVarsWithTypes_go subst (Strip.deannotateType t)
+
+substituteTypeVarsWithTypes_go :: M.Map Core.Name Core.Type -> Core.Type -> Core.Type
+substituteTypeVarsWithTypes_go subst t =
+    case (Strip.deannotateType t) of
+      Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 subst) t (\rep -> rep)
+      Core.TypeFunction v0 -> Core.TypeFunction (Core.FunctionType {
+        Core.functionTypeDomain = (substituteTypeVarsWithTypes_go subst (Core.functionTypeDomain v0)),
+        Core.functionTypeCodomain = (substituteTypeVarsWithTypes_go subst (Core.functionTypeCodomain v0))})
+      Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType {
+        Core.applicationTypeFunction = (substituteTypeVarsWithTypes_go subst (Core.applicationTypeFunction v0)),
+        Core.applicationTypeArgument = (substituteTypeVarsWithTypes_go subst (Core.applicationTypeArgument v0))})
+      Core.TypeList v0 -> Core.TypeList (substituteTypeVarsWithTypes_go subst v0)
+      Core.TypeSet v0 -> Core.TypeSet (substituteTypeVarsWithTypes_go subst v0)
+      Core.TypeOptional v0 -> Core.TypeOptional (substituteTypeVarsWithTypes_go subst v0)
+      Core.TypeEffect v0 -> Core.TypeEffect (substituteTypeVarsWithTypes_go subst v0)
+      Core.TypeMap v0 -> Core.TypeMap (Core.MapType {
+        Core.mapTypeKeys = (substituteTypeVarsWithTypes_go subst (Core.mapTypeKeys v0)),
+        Core.mapTypeValues = (substituteTypeVarsWithTypes_go subst (Core.mapTypeValues v0))})
+      Core.TypePair v0 -> Core.TypePair (Core.PairType {
+        Core.pairTypeFirst = (substituteTypeVarsWithTypes_go subst (Core.pairTypeFirst v0)),
+        Core.pairTypeSecond = (substituteTypeVarsWithTypes_go subst (Core.pairTypeSecond v0))})
+      Core.TypeEither v0 -> Core.TypeEither (Core.EitherType {
+        Core.eitherTypeLeft = (substituteTypeVarsWithTypes_go subst (Core.eitherTypeLeft v0)),
+        Core.eitherTypeRight = (substituteTypeVarsWithTypes_go subst (Core.eitherTypeRight v0))})
+      Core.TypeForall v0 -> Core.TypeForall (Core.ForallType {
+        Core.forallTypeParameter = (Core.forallTypeParameter v0),
+        Core.forallTypeBody = (substituteTypeVarsWithTypes_go subst (Core.forallTypeBody v0))})
+      _ -> t
+
+tagCmpNotZeroExpr :: Syntax.Expression
+tagCmpNotZeroExpr =
+    Utils.javaEqualityExpressionToJavaExpression (Syntax.EqualityExpressionNotEqual (Syntax.EqualityExpression_Binary {
+      Syntax.equalityExpression_BinaryLhs = lhs,
+      Syntax.equalityExpression_BinaryRhs = rhs}))
+  where
+    lhs =
+        Utils.javaRelationalExpressionToJavaEqualityExpression (Utils.javaPostfixExpressionToJavaRelationalExpression (Syntax.PostfixExpressionName (Syntax.ExpressionName {
+          Syntax.expressionNameQualifier = Nothing,
+          Syntax.expressionNameIdentifier = (Utils.javaIdentifier "tagCmp")})))
+    rhs =
+        Utils.javaPostfixExpressionToJavaRelationalExpression (Syntax.PostfixExpressionPrimary (Utils.javaLiteralToJavaPrimary (Utils.javaInt 0)))
+
+tagCompareExpr :: Syntax.Expression
+tagCompareExpr =
+    Utils.javaMethodInvocationToJavaExpression (Syntax.MethodInvocation {
+      Syntax.methodInvocationHeader = (Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+        Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantPrimary (Utils.javaMethodInvocationToJavaPrimary thisGetName)),
+        Syntax.methodInvocation_ComplexTypeArguments = [],
+        Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier JavaNames.compareToMethodName)})),
+      Syntax.methodInvocationArguments = [
+        Utils.javaMethodInvocationToJavaExpression otherGetName]})
+  where
+    thisGetClass =
+        Syntax.MethodInvocation {
+          Syntax.methodInvocationHeader = (Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+            Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantPrimary (Utils.javaExpressionToJavaPrimary Utils.javaThis)),
+            Syntax.methodInvocation_ComplexTypeArguments = [],
+            Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier "getClass")})),
+          Syntax.methodInvocationArguments = []}
+    thisGetName =
+        Syntax.MethodInvocation {
+          Syntax.methodInvocationHeader = (Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+            Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantPrimary (Utils.javaMethodInvocationToJavaPrimary thisGetClass)),
+            Syntax.methodInvocation_ComplexTypeArguments = [],
+            Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier "getName")})),
+          Syntax.methodInvocationArguments = []}
+    otherGetClass =
+        Syntax.MethodInvocation {
+          Syntax.methodInvocationHeader = (Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+            Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantExpression (Syntax.ExpressionName {
+              Syntax.expressionNameQualifier = Nothing,
+              Syntax.expressionNameIdentifier = (Syntax.Identifier JavaNames.otherInstanceName)})),
+            Syntax.methodInvocation_ComplexTypeArguments = [],
+            Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier "getClass")})),
+          Syntax.methodInvocationArguments = []}
+    otherGetName =
+        Syntax.MethodInvocation {
+          Syntax.methodInvocationHeader = (Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+            Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantPrimary (Utils.javaMethodInvocationToJavaPrimary otherGetClass)),
+            Syntax.methodInvocation_ComplexTypeArguments = [],
+            Syntax.methodInvocation_ComplexIdentifier = (Syntax.Identifier "getName")})),
+          Syntax.methodInvocationArguments = []}
+
+takeTypeArgs :: String -> Int -> [Syntax.Type] -> t0 -> t1 -> Either Errors.Error [Syntax.TypeArgument]
+takeTypeArgs label n tyapps cx g =
+    Logic.ifElse (Equality.lt (Lists.length tyapps) n) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat [
+      "needed type arguments for ",
+      label,
+      ", found too few"])))) (Eithers.mapList (\jt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jt cx) (\rt -> Right (Syntax.TypeArgumentReference rt))) (Lists.take n tyapps))
+
+toClassDecl :: Bool -> Bool -> JavaEnvironment.Aliases -> [Syntax.TypeParameter] -> Core.Name -> Core.Type -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassDeclaration
+toClassDecl isInner isSer aliases tparams elName t cx g =
+
+      let wrap =
+              \t_ -> declarationForRecordType isInner isSer aliases tparams elName [
+                Core.FieldType {
+                  Core.fieldTypeName = (Core.Name "value"),
+                  Core.fieldTypeType = (Strip.deannotateType t_)}] cx g
+      in case (Strip.deannotateType t) of
+        Core.TypeRecord v0 -> declarationForRecordType isInner isSer aliases tparams elName v0 cx g
+        Core.TypeUnion v0 -> declarationForUnionType isSer aliases tparams elName v0 cx g
+        Core.TypeForall v0 ->
+          let v = Core.forallTypeParameter v0
+              body = Core.forallTypeBody v0
+              param = Utils.javaTypeParameter (Formatting.capitalize (Core.unName v))
+          in (toClassDecl False isSer aliases (Lists.concat2 tparams [
+            param]) elName body cx g)
+        Core.TypeWrap v0 -> declarationForRecordType isInner isSer aliases tparams elName [
+          Core.FieldType {
+            Core.fieldTypeName = (Core.Name "value"),
+            Core.fieldTypeType = v0}] cx g
+        _ -> wrap t
+
+toDeclInit :: JavaEnvironment.Aliases -> Graph.Graph -> S.Set Core.Name -> [Core.Binding] -> Core.Name -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error (Maybe Syntax.BlockStatement)
+toDeclInit aliasesExt gExt recursiveVars flatBindings name cx g =
+    Logic.ifElse (Sets.member name recursiveVars) (
+      let binding =
+              Optionals.fromOptional (Core.Binding {
+                Core.bindingName = name,
+                Core.bindingTerm = Core.TermUnit,
+                Core.bindingTypeScheme = Nothing}) (Lists.maybeHead (Lists.filter (\b -> Equality.equal (Core.bindingName b) name) flatBindings))
+          value = Core.bindingTerm binding
+      in (Eithers.bind (Optionals.cases (Core.bindingTypeScheme binding) (Checking.typeOfTerm cx gExt value) (\ts -> Right (Core.typeSchemeBody ts))) (\typ -> Eithers.bind (encodeType aliasesExt Sets.empty typ cx g) (\jtype ->
+        let id = Utils.variableToJavaIdentifier name
+            arid = Syntax.Identifier "java.util.concurrent.atomic.AtomicReference"
+            aid =
+                    Syntax.AnnotatedIdentifier {
+                      Syntax.annotatedIdentifierAnnotations = [],
+                      Syntax.annotatedIdentifierIdentifier = arid}
+        in (Eithers.bind (Utils.javaTypeToJavaReferenceType jtype cx) (\rt ->
+          let targs = typeArgsOrDiamond [
+                Syntax.TypeArgumentReference rt]
+              ci =
+                      Syntax.ClassOrInterfaceTypeToInstantiate {
+                        Syntax.classOrInterfaceTypeToInstantiateIdentifiers = [
+                          aid],
+                        Syntax.classOrInterfaceTypeToInstantiateTypeArguments = (Just targs)}
+              body = Utils.javaConstructorCall ci [] Nothing
+              pkg =
+                      JavaNames.javaPackageName [
+                        "java",
+                        "util",
+                        "concurrent",
+                        "atomic"]
+              artype = Utils.javaRefType [
+                    rt] (Just pkg) "AtomicReference"
+          in (Right (Just (Utils.variableDeclarationStatement aliasesExt artype id body))))))))) (Right Nothing)
+
+toDeclStatement :: JavaEnvironment.JavaEnvironment -> JavaEnvironment.Aliases -> Graph.Graph -> S.Set Core.Name -> S.Set Core.Name -> [Core.Binding] -> Core.Name -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.BlockStatement
+toDeclStatement envExt aliasesExt gExt recursiveVars thunkedVars flatBindings name cx g =
+
+      let binding =
+              Optionals.fromOptional (Core.Binding {
+                Core.bindingName = name,
+                Core.bindingTerm = Core.TermUnit,
+                Core.bindingTypeScheme = Nothing}) (Lists.maybeHead (Lists.filter (\b -> Equality.equal (Core.bindingName b) name) flatBindings))
+          value = Core.bindingTerm binding
+      in (Eithers.bind (Optionals.cases (Core.bindingTypeScheme binding) (Checking.typeOfTerm cx gExt value) (\ts -> Right (Core.typeSchemeBody ts))) (\typ -> Eithers.bind (encodeType aliasesExt Sets.empty typ cx g) (\jtype ->
+        let id = Utils.variableToJavaIdentifier name
+            annotatedValue = Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ typ)) value
+        in (Eithers.bind (encodeTerm envExt annotatedValue cx g) (\rhs -> Logic.ifElse (Sets.member name recursiveVars) (Right (Syntax.BlockStatementStatement (Utils.javaMethodInvocationToJavaStatement (Utils.methodInvocation (Just (Left (Syntax.ExpressionName {
+          Syntax.expressionNameQualifier = Nothing,
+          Syntax.expressionNameIdentifier = id}))) (Syntax.Identifier JavaNames.setMethodName) [
+          rhs])))) (Logic.ifElse (Sets.member name thunkedVars) (Eithers.bind (Utils.javaTypeToJavaReferenceType jtype cx) (\rt ->
+          let lazyType = Utils.javaRefType [
+                rt] JavaNames.hydraUtilPackageName "Lazy"
+              lambdaBody = Syntax.LambdaBodyExpression rhs
+              supplierLambda =
+                      Syntax.ExpressionLambda (Syntax.LambdaExpression {
+                        Syntax.lambdaExpressionParameters = (Syntax.LambdaParametersTuple []),
+                        Syntax.lambdaExpressionBody = lambdaBody})
+              targs = typeArgsOrDiamond [
+                    Syntax.TypeArgumentReference rt]
+              lazyExpr =
+                      Utils.javaConstructorCall (Utils.javaConstructorName (Syntax.Identifier "hydra.overlay.java.util.Lazy") (Just targs)) [
+                        supplierLambda] Nothing
+          in (Right (Utils.variableDeclarationStatement aliasesExt lazyType id lazyExpr)))) (Right (Utils.variableDeclarationStatement aliasesExt jtype id rhs))))))))
+
+tryInferFunctionType :: Core.Term -> Maybe Core.Type
+tryInferFunctionType funTerm =
+    case (Strip.deannotateTerm funTerm) of
+      Core.TermLambda v0 -> Optionals.bind (Core.lambdaDomain v0) (\dom ->
+        let mCod =
+                case (Core.lambdaBody v0) of
+                  Core.TermAnnotated v1 -> Optionals.bind (Maps.lookup Constants.keyType (Annotations.getAnnotationMap (Core.annotatedTermAnnotation v1))) (\typeTerm -> decodeTypeFromTerm typeTerm)
+                  Core.TermLambda _ -> tryInferFunctionType (Core.lambdaBody v0)
+                  _ -> Nothing
+        in (Optionals.map (\cod -> Core.TypeFunction (Core.FunctionType {
+          Core.functionTypeDomain = dom,
+          Core.functionTypeCodomain = cod})) mCod))
+      _ -> Nothing
+
+typeAppFallbackCast :: JavaEnvironment.JavaEnvironment -> JavaEnvironment.Aliases -> [M.Map Core.Name Core.Term] -> [Syntax.Type] -> Syntax.Type -> Core.Term -> Core.Type -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+typeAppFallbackCast env aliases anns tyapps jatyp body typ cx g =
+
+      let annotatedBody = Annotations.setTermAnnotation Constants.keyType (Just (EncodeCore.type_ typ)) body
+      in (Eithers.bind (encodeTermInternal env anns (Lists.cons jatyp tyapps) annotatedBody cx g) (\jbody -> Eithers.bind (encodeType aliases Sets.empty typ cx g) (\jtype -> Eithers.bind (Utils.javaTypeToJavaReferenceType jtype cx) (\rt -> Right (Utils.javaCastExpressionToJavaExpression (Utils.javaCastExpression rt (Utils.javaExpressionToJavaUnaryExpression jbody)))))))
+
+typeAppNullaryOrHoisted :: JavaEnvironment.JavaEnvironment -> JavaEnvironment.Aliases -> [M.Map Core.Name Core.Term] -> [Syntax.Type] -> Syntax.Type -> Core.Term -> Core.Type -> Core.Name -> JavaEnvironment.JavaSymbolClass -> [Core.Type] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.Expression
+typeAppNullaryOrHoisted env aliases anns tyapps jatyp body correctedTyp varName cls allTypeArgs cx g =
+
+      let qn = Names.qualifyName varName
+          mns = Util.qualifiedNameModuleName qn
+          localName = Util.qualifiedNameLocal qn
+      in case cls of
+        JavaEnvironment.JavaSymbolClassNullaryFunction -> Optionals.cases mns (typeAppFallbackCast env aliases anns tyapps jatyp body correctedTyp cx g) (\ns_ ->
+          let classId = Utils.nameToJavaName aliases (elementsQualifiedName ns_)
+              methodId = Syntax.Identifier (Utils.sanitizeJavaName localName)
+          in (Eithers.bind (filterPhantomTypeArgs varName allTypeArgs cx g) (\filteredTypeArgs -> Eithers.bind (Eithers.mapList (\t -> Eithers.bind (encodeType aliases Sets.empty t cx g) (\jt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jt cx) (\rt -> Right (Syntax.TypeArgumentReference rt)))) filteredTypeArgs) (\jTypeArgs -> Right (Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs classId methodId jTypeArgs []))))))
+        JavaEnvironment.JavaSymbolClassHoistedLambda v0 -> Optionals.cases mns (typeAppFallbackCast env aliases anns tyapps jatyp body correctedTyp cx g) (\ns_ ->
+          let classId = Utils.nameToJavaName aliases (elementsQualifiedName ns_)
+              methodId = Syntax.Identifier (Utils.sanitizeJavaName localName)
+          in (Eithers.bind (filterPhantomTypeArgs varName allTypeArgs cx g) (\filteredTypeArgs -> Eithers.bind (Eithers.mapList (\t -> Eithers.bind (encodeType aliases Sets.empty t cx g) (\jt -> Eithers.bind (Utils.javaTypeToJavaReferenceType jt cx) (\rt -> Right (Syntax.TypeArgumentReference rt)))) filteredTypeArgs) (\jTypeArgs ->
+            let paramNames = Lists.map (\i -> Core.Name (Strings.cat2 "p" (Literals.showInt32 i))) (Math.range 0 (Math.sub v0 1))
+                paramExprs = Lists.map (\p -> Utils.javaIdentifierToJavaExpression (Utils.variableToJavaIdentifier p)) paramNames
+                call =
+                        Utils.javaMethodInvocationToJavaExpression (Utils.methodInvocationStaticWithTypeArgs classId methodId jTypeArgs paramExprs)
+            in (Right (buildCurriedLambda paramNames call))))))
+        _ -> typeAppFallbackCast env aliases anns tyapps jatyp body correctedTyp cx g
+
+typeArgsOrDiamond :: [Syntax.TypeArgument] -> Syntax.TypeArgumentsOrDiamond
+typeArgsOrDiamond args =
+    Logic.ifElse (JavaEnvironment.javaFeaturesSupportsDiamondOperator javaFeatures) Syntax.TypeArgumentsOrDiamondDiamond (Syntax.TypeArgumentsOrDiamondArguments args)
+
+typesMatch :: Core.Type -> Core.Type -> Bool
+typesMatch a b =
+    case a of
+      Core.TypeVariable v0 -> case b of
+        Core.TypeVariable v1 -> Equality.equal v0 v1
+        _ -> True
+      Core.TypeWrap v0 -> case b of
+        Core.TypeWrap v1 -> Equality.equal v0 v1
+        _ -> True
+      _ -> True
+
+unwrapReturnType :: Core.Type -> Core.Type
+unwrapReturnType t =
+    case (Strip.deannotateType t) of
+      Core.TypeFunction v0 -> unwrapReturnType (Core.functionTypeCodomain v0)
+      Core.TypeApplication v0 -> unwrapReturnType (Core.applicationTypeArgument v0)
+      _ -> t
+
+variantCompareToMethod :: JavaEnvironment.Aliases -> t0 -> Core.Name -> Core.Name -> [Core.FieldType] -> Syntax.ClassBodyDeclaration
+variantCompareToMethod aliases tparams parentName variantName fields =
+
+      let anns =
+              [
+                Utils.overrideAnnotation,
+                Utils.suppressWarningsUncheckedAnnotation]
+          mods = [
+                Syntax.MethodModifierPublic]
+          param =
+                  Utils.javaTypeToJavaFormalParameter (Utils.javaTypeFromTypeName aliases parentName) (Core.Name JavaNames.otherInstanceName)
+          result = Utils.javaTypeToJavaResult Utils.javaIntType
+          varTmpName = "o"
+          tagDeclStmt = Utils.variableDeclarationStatement aliases Utils.javaIntType (Utils.javaIdentifier "tagCmp") tagCompareExpr
+          tagReturnStmt =
+                  Syntax.BlockStatementStatement (Syntax.StatementIfThen (Syntax.IfThenStatement {
+                    Syntax.ifThenStatementExpression = tagCmpNotZeroExpr,
+                    Syntax.ifThenStatementStatement = (Utils.javaReturnStatement (Just (Utils.javaExpressionNameToJavaExpression (Syntax.ExpressionName {
+                      Syntax.expressionNameQualifier = Nothing,
+                      Syntax.expressionNameIdentifier = (Utils.javaIdentifier "tagCmp")}))))}))
+          variantJavaType = Utils.javaTypeFromTypeName aliases variantName
+          castOtherExpr =
+                  Utils.javaCastExpressionToJavaExpression (Utils.javaCastExpression (Utils.nameToJavaReferenceType aliases False [] variantName Nothing) (Utils.javaIdentifierToJavaUnaryExpression (Syntax.Identifier JavaNames.otherInstanceName)))
+          castDeclStmt = Utils.variableDeclarationStatement aliases variantJavaType (Utils.javaIdentifier varTmpName) castOtherExpr
+          emptyReturn = [
+                Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just (Utils.javaIntExpression 0)))]
+          valueCompareStmt =
+                  Logic.ifElse (Lists.null fields) emptyReturn (Lists.concat2 [
+                    castDeclStmt] (compareToBody aliases varTmpName fields))
+          body =
+                  Lists.concat2 [
+                    tagDeclStmt,
+                    tagReturnStmt] valueCompareStmt
+      in (Utils.methodDeclaration mods [] anns JavaNames.compareToMethodName [
+        param] result (Just body))
+
+visitBranch :: JavaEnvironment.JavaEnvironment -> JavaEnvironment.Aliases -> Core.Type -> Core.Name -> Syntax.Type -> [Syntax.TypeArgument] -> Core.CaseAlternative -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error Syntax.ClassBodyDeclarationWithComments
+visitBranch env aliases dom tname jcod targs field cx g =
+
+      let jdom =
+              Syntax.TypeReference (Utils.nameToJavaReferenceType aliases True targs tname (Just (Formatting.capitalize (Core.unName (Core.caseAlternativeName field)))))
+          mods = [
+                Syntax.MethodModifierPublic]
+          anns = [
+                Utils.overrideAnnotation]
+          result = Syntax.ResultType (Syntax.UnannType jcod)
+      in case (Strip.deannotateTerm (Core.caseAlternativeHandler field)) of
+        Core.TermLambda v0 -> withLambda env v0 (\env2 ->
+          let lambdaParam = Core.lambdaParameter v0
+              body = Core.lambdaBody v0
+              env3 = insertBranchVar lambdaParam env2
+          in (Eithers.bind (analyzeJavaFunction env3 body cx g) (\fs ->
+            let bindings = Typing.functionStructureBindings fs
+                innerBody = Typing.functionStructureBody fs
+                env4 = Typing.functionStructureEnvironment fs
+            in (Eithers.bind (bindingsToStatements env4 bindings cx g) (\bindResult ->
+              let bindingStmts = Pairs.first bindResult
+                  env5 = Pairs.second bindResult
+              in (Eithers.bind (encodeTerm env5 innerBody cx g) (\jret ->
+                let param = Utils.javaTypeToJavaFormalParameter jdom lambdaParam
+                    returnStmt = Syntax.BlockStatementStatement (Utils.javaReturnStatement (Just jret))
+                    allStmts = Lists.concat2 bindingStmts [
+                          returnStmt]
+                in (Right (noComment (Utils.methodDeclaration mods [] anns JavaNames.visitMethodName [
+                  param] result (Just allStmts)))))))))))
+        _ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "visitBranch: field term is not a lambda: " (ShowCore.term (Core.caseAlternativeHandler field)))))
+
+withCommentString :: String -> Syntax.ClassBodyDeclaration -> Syntax.ClassBodyDeclarationWithComments
+withCommentString comment decl =
+    Syntax.ClassBodyDeclarationWithComments {
+      Syntax.classBodyDeclarationWithCommentsValue = decl,
+      Syntax.classBodyDeclarationWithCommentsComments = (Just comment)}
+
+withInterfaceCommentString :: String -> Syntax.InterfaceMemberDeclaration -> Syntax.InterfaceMemberDeclarationWithComments
+withInterfaceCommentString comment decl =
+    Syntax.InterfaceMemberDeclarationWithComments {
+      Syntax.interfaceMemberDeclarationWithCommentsValue = decl,
+      Syntax.interfaceMemberDeclarationWithCommentsComments = (Just comment)}
+
+withLambda :: JavaEnvironment.JavaEnvironment -> Core.Lambda -> (JavaEnvironment.JavaEnvironment -> t0) -> t0
+withLambda env lam k =
+    Environment.withLambdaContext javaEnvGetGraph javaEnvSetGraph env lam (\env1 ->
+      let aliases = JavaEnvironment.javaEnvironmentAliases env1
+          aliases2 =
+                  JavaEnvironment.Aliases {
+                    JavaEnvironment.aliasesCurrentNamespace = (JavaEnvironment.aliasesCurrentNamespace aliases),
+                    JavaEnvironment.aliasesPackages = (JavaEnvironment.aliasesPackages aliases),
+                    JavaEnvironment.aliasesBranchVars = (JavaEnvironment.aliasesBranchVars aliases),
+                    JavaEnvironment.aliasesRecursiveVars = (JavaEnvironment.aliasesRecursiveVars aliases),
+                    JavaEnvironment.aliasesInScopeTypeParams = (JavaEnvironment.aliasesInScopeTypeParams aliases),
+                    JavaEnvironment.aliasesPolymorphicLocals = (JavaEnvironment.aliasesPolymorphicLocals aliases),
+                    JavaEnvironment.aliasesInScopeJavaVars = (JavaEnvironment.aliasesInScopeJavaVars aliases),
+                    JavaEnvironment.aliasesVarRenames = (JavaEnvironment.aliasesVarRenames aliases),
+                    JavaEnvironment.aliasesLambdaVars = (Sets.insert (Core.lambdaParameter lam) (JavaEnvironment.aliasesLambdaVars aliases)),
+                    JavaEnvironment.aliasesTypeVarSubst = (JavaEnvironment.aliasesTypeVarSubst aliases),
+                    JavaEnvironment.aliasesTrustedTypeVars = (JavaEnvironment.aliasesTrustedTypeVars aliases),
+                    JavaEnvironment.aliasesMethodCodomain = (JavaEnvironment.aliasesMethodCodomain aliases),
+                    JavaEnvironment.aliasesThunkedVars = (JavaEnvironment.aliasesThunkedVars aliases)}
+          env2 =
+                  JavaEnvironment.JavaEnvironment {
+                    JavaEnvironment.javaEnvironmentAliases = aliases2,
+                    JavaEnvironment.javaEnvironmentGraph = (JavaEnvironment.javaEnvironmentGraph env1)}
+      in (k env2))
+
+withTypeLambda :: JavaEnvironment.JavaEnvironment -> Core.TypeLambda -> (JavaEnvironment.JavaEnvironment -> t0) -> t0
+withTypeLambda = Environment.withTypeLambdaContext javaEnvGetGraph javaEnvSetGraph
+
+wrapInSupplierLambda :: Syntax.Expression -> Syntax.Expression
+wrapInSupplierLambda expr =
+    Syntax.ExpressionLambda (Syntax.LambdaExpression {
+      Syntax.lambdaExpressionParameters = (Syntax.LambdaParametersTuple []),
+      Syntax.lambdaExpressionBody = (Syntax.LambdaBodyExpression expr)})
+
+wrapLazyArguments :: Graph.Graph -> Core.Name -> [Syntax.Expression] -> ([Syntax.Expression], (Maybe String))
+wrapLazyArguments g name args =
+
+      let lazyFlags = lazyFlagsForPrimitive g name
+          anyLazy = Lists.foldl (\b -> \f -> Logic.or b f) False lazyFlags
+      in (Logic.ifElse (Logic.and anyLazy (Equality.equal (Lists.length args) (Lists.length lazyFlags))) (
+        Lists.map (\pair -> Logic.ifElse (Pairs.second pair) (wrapInSupplierLambda (Pairs.first pair)) (Pairs.first pair)) (Lists.zip args lazyFlags),
+        (Just (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.logic.ifElse")) "lazy" "applyLazy"))) (args, Nothing))
diff --git a/src/main/haskell/Hydra/Java/Environment.hs b/src/main/haskell/Hydra/Java/Environment.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Java/Environment.hs
@@ -0,0 +1,125 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Environment types for Java code generation
+
+module Hydra.Java.Environment where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Java.Syntax as Syntax
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Typing as Typing
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Map as M
+import qualified Data.Set as S
+
+-- | Classification of a Java symbol for code generation
+data JavaSymbolClass =
+  -- | A constant value
+  JavaSymbolClassConstant |
+  -- | A nullary function (no arguments)
+  JavaSymbolClassNullaryFunction |
+  -- | A hoisted lambda wrapped in type lambdas. The Int is the number of curried lambda parameters.
+  JavaSymbolClassHoistedLambda Int |
+  -- | A unary function (single argument)
+  JavaSymbolClassUnaryFunction |
+  -- | A local variable
+  JavaSymbolClassLocalVariable
+  deriving (Eq, Ord, Read, Show)
+
+_JavaSymbolClass = Core.Name "hydra.java.environment.JavaSymbolClass"
+
+_JavaSymbolClass_constant = Core.Name "constant"
+
+_JavaSymbolClass_nullaryFunction = Core.Name "nullaryFunction"
+
+_JavaSymbolClass_hoistedLambda = Core.Name "hoistedLambda"
+
+_JavaSymbolClass_unaryFunction = Core.Name "unaryFunction"
+
+_JavaSymbolClass_localVariable = Core.Name "localVariable"
+
+-- | Feature flags for the target Java version
+data JavaFeatures =
+  JavaFeatures {
+    -- | Whether the diamond operator (<>) is supported (Java 7+)
+    javaFeaturesSupportsDiamondOperator :: Bool}
+  deriving (Eq, Ord, Read, Show)
+
+_JavaFeatures = Core.Name "hydra.java.environment.JavaFeatures"
+
+_JavaFeatures_supportsDiamondOperator = Core.Name "supportsDiamondOperator"
+
+-- | Aliases and context for Java code generation
+data Aliases =
+  Aliases {
+    -- | Current module name context
+    aliasesCurrentNamespace :: Packaging.ModuleName,
+    -- | Maps module names to Java package names
+    aliasesPackages :: (M.Map Packaging.ModuleName Syntax.PackageName),
+    -- | Variables bound in pattern matching branches
+    aliasesBranchVars :: (S.Set Core.Name),
+    -- | Variables that are self-recursive
+    aliasesRecursiveVars :: (S.Set Core.Name),
+    -- | Type parameters that are in scope (from method-level type parameters)
+    aliasesInScopeTypeParams :: (S.Set Core.Name),
+    -- | Local variables that have polymorphic types (declared with raw types)
+    aliasesPolymorphicLocals :: (S.Set Core.Name),
+    -- | All in-scope Java variable names (for avoiding lambda parameter shadowing)
+    aliasesInScopeJavaVars :: (S.Set Core.Name),
+    -- | Variable renames for avoiding shadowing (maps Hydra name to Java name)
+    aliasesVarRenames :: (M.Map Core.Name Core.Name),
+    -- | Lambda-bound variables (including hoisted captures with qualified names)
+    aliasesLambdaVars :: (S.Set Core.Name),
+    -- | Type variable substitution: maps fresh inference variable names to canonical scheme variable names
+    aliasesTypeVarSubst :: (M.Map Core.Name Core.Name),
+    -- | Type variables that actually appear in the method's formal parameter types
+    aliasesTrustedTypeVars :: (S.Set Core.Name),
+    -- | The enclosing method's codomain (return type), used for casting pair expressions
+    aliasesMethodCodomain :: (Maybe Core.Type),
+    -- | Variables that have been thunked (wrapped in Supplier) for lazy evaluation
+    aliasesThunkedVars :: (S.Set Core.Name)}
+  deriving (Eq, Ord, Read, Show)
+
+_Aliases = Core.Name "hydra.java.environment.Aliases"
+
+_Aliases_currentNamespace = Core.Name "currentNamespace"
+
+_Aliases_packages = Core.Name "packages"
+
+_Aliases_branchVars = Core.Name "branchVars"
+
+_Aliases_recursiveVars = Core.Name "recursiveVars"
+
+_Aliases_inScopeTypeParams = Core.Name "inScopeTypeParams"
+
+_Aliases_polymorphicLocals = Core.Name "polymorphicLocals"
+
+_Aliases_inScopeJavaVars = Core.Name "inScopeJavaVars"
+
+_Aliases_varRenames = Core.Name "varRenames"
+
+_Aliases_lambdaVars = Core.Name "lambdaVars"
+
+_Aliases_typeVarSubst = Core.Name "typeVarSubst"
+
+_Aliases_trustedTypeVars = Core.Name "trustedTypeVars"
+
+_Aliases_methodCodomain = Core.Name "methodCodomain"
+
+_Aliases_thunkedVars = Core.Name "thunkedVars"
+
+-- | Environment for Java code generation
+data JavaEnvironment =
+  JavaEnvironment {
+    -- | Aliases and context state
+    javaEnvironmentAliases :: Aliases,
+    -- | Graph context for type inference
+    javaEnvironmentGraph :: Graph.Graph}
+
+_JavaEnvironment = Core.Name "hydra.java.environment.JavaEnvironment"
+
+_JavaEnvironment_aliases = Core.Name "aliases"
+
+_JavaEnvironment_graph = Core.Name "graph"
diff --git a/src/main/haskell/Hydra/Java/Language.hs b/src/main/haskell/Hydra/Java/Language.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Java/Language.hs
@@ -0,0 +1,298 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Language constraints and reserved words for Java
+
+module Hydra.Java.Language where
+
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Classes as Classes
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+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.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+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 Java
+javaLanguage :: Coders.Language
+javaLanguage =
+    Coders.Language {
+      Coders.languageName = (Coders.LanguageName "hydra.java"),
+      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.LanguageFeatureNestedCaseStatements]),
+      Coders.languageCaseConventions = Coders.CaseConventions {
+        Coders.caseConventionsConstant = Util.CaseConventionUpperSnake,
+        Coders.caseConventionsDirectory = Util.CaseConventionCamel,
+        Coders.caseConventionsEnumValue = Util.CaseConventionUpperSnake,
+        Coders.caseConventionsField = Util.CaseConventionCamel,
+        Coders.caseConventionsFile = Util.CaseConventionPascal,
+        Coders.caseConventionsModule = Util.CaseConventionCamel,
+        Coders.caseConventionsTerm = Util.CaseConventionCamel,
+        Coders.caseConventionsTermVariable = Util.CaseConventionCamel,
+        Coders.caseConventionsType = Util.CaseConventionPascal,
+        Coders.caseConventionsTypeVariable = Util.CaseConventionPascal},
+      Coders.languageDefaultFileExtension = (File.FileExtension "java")}
+  where
+    literalVariants =
+        Sets.fromList [
+          Variants.LiteralVariantBinary,
+          Variants.LiteralVariantBoolean,
+          Variants.LiteralVariantDecimal,
+          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.IntegerTypeUint16]
+    termVariants =
+        Sets.fromList [
+          Variants.TermVariantApplication,
+          Variants.TermVariantEither,
+          Variants.TermVariantCases,
+          Variants.TermVariantLambda,
+          Variants.TermVariantProject,
+          Variants.TermVariantUnwrap,
+          Variants.TermVariantTypeApplication,
+          Variants.TermVariantTypeLambda,
+          Variants.TermVariantLet,
+          Variants.TermVariantList,
+          Variants.TermVariantLiteral,
+          Variants.TermVariantMap,
+          Variants.TermVariantOptional,
+          Variants.TermVariantPair,
+          Variants.TermVariantRecord,
+          Variants.TermVariantSet,
+          Variants.TermVariantInject,
+          Variants.TermVariantUnit,
+          Variants.TermVariantVariable,
+          Variants.TermVariantWrap]
+    typeVariants =
+        Sets.fromList [
+          Variants.TypeVariantAnnotated,
+          Variants.TypeVariantApplication,
+          Variants.TypeVariantEither,
+          Variants.TypeVariantEffect,
+          Variants.TypeVariantFunction,
+          Variants.TypeVariantForall,
+          Variants.TypeVariantList,
+          Variants.TypeVariantLiteral,
+          Variants.TypeVariantMap,
+          Variants.TypeVariantOptional,
+          Variants.TypeVariantPair,
+          Variants.TypeVariantRecord,
+          Variants.TypeVariantSet,
+          Variants.TypeVariantUnion,
+          Variants.TypeVariantUnit,
+          Variants.TypeVariantVariable,
+          Variants.TypeVariantVoid,
+          Variants.TypeVariantWrap]
+    typePredicate = \_ -> True
+
+-- | The maximum supported length of a tuple in Hydra-Java. Note: if this constant is changed, also change Tuples.java correspondingly
+javaMaxTupleLength :: Int
+javaMaxTupleLength = 9
+
+-- | A set of reserved words in Java
+reservedWords :: S.Set String
+reservedWords =
+    Sets.fromList (Lists.concat [
+      specialNames,
+      classNames,
+      keywords,
+      literals])
+  where
+    specialNames = [
+      "Elements"]
+    classNames =
+        [
+          "AbstractMethodError",
+          "Appendable",
+          "ArithmeticException",
+          "ArrayIndexOutOfBoundsException",
+          "ArrayStoreException",
+          "AssertionError",
+          "AutoCloseable",
+          "Boolean",
+          "BootstrapMethodError",
+          "Byte",
+          "CharSequence",
+          "Character",
+          "Class",
+          "ClassCastException",
+          "ClassCircularityError",
+          "ClassFormatError",
+          "ClassLoader",
+          "ClassNotFoundException",
+          "ClassValue",
+          "CloneNotSupportedException",
+          "Cloneable",
+          "Comparable",
+          "Compiler",
+          "Deprecated",
+          "Double",
+          "Enum",
+          "EnumConstantNotPresentException",
+          "Error",
+          "Exception",
+          "ExceptionInInitializerError",
+          "Float",
+          "IllegalAccessError",
+          "IllegalAccessException",
+          "IllegalArgumentException",
+          "IllegalMonitorStateException",
+          "IllegalStateException",
+          "IllegalThreadStateException",
+          "IncompatibleClassChangeError",
+          "IndexOutOfBoundsException",
+          "InheritableThreadLocal",
+          "InstantiationError",
+          "InstantiationException",
+          "Integer",
+          "InternalError",
+          "InterruptedException",
+          "Iterable",
+          "LinkageError",
+          "Long",
+          "Math",
+          "NegativeArraySizeException",
+          "NoClassDefFoundError",
+          "NoSuchFieldError",
+          "NoSuchFieldException",
+          "NoSuchMethodError",
+          "NoSuchMethodException",
+          "NullPointerException",
+          "Number",
+          "NumberFormatException",
+          "Object",
+          "OutOfMemoryError",
+          "Override",
+          "Package",
+          "Process",
+          "ProcessBuilder",
+          "Readable",
+          "ReflectiveOperationException",
+          "Runnable",
+          "Runtime",
+          "RuntimeException",
+          "RuntimePermission",
+          "SafeVarargs",
+          "SecurityException",
+          "SecurityManager",
+          "Short",
+          "StackOverflowError",
+          "StackTraceElement",
+          "StrictMath",
+          "String",
+          "StringBuffer",
+          "StringBuilder",
+          "StringIndexOutOfBoundsException",
+          "SuppressWarnings",
+          "System",
+          "Thread",
+          "ThreadDeath",
+          "ThreadGroup",
+          "ThreadLocal",
+          "Throwable",
+          "TypeNotPresentException",
+          "UnknownError",
+          "UnsatisfiedLinkError",
+          "UnsupportedClassVersionError",
+          "UnsupportedOperationException",
+          "VerifyError",
+          "VirtualMachineError",
+          "Void"]
+    keywords =
+        [
+          "abstract",
+          "assert",
+          "boolean",
+          "break",
+          "byte",
+          "case",
+          "catch",
+          "char",
+          "class",
+          "const",
+          "continue",
+          "default",
+          "do",
+          "double",
+          "else",
+          "enum",
+          "extends",
+          "final",
+          "finally",
+          "float",
+          "for",
+          "goto",
+          "if",
+          "implements",
+          "import",
+          "instanceof",
+          "int",
+          "interface",
+          "long",
+          "native",
+          "new",
+          "package",
+          "private",
+          "protected",
+          "public",
+          "return",
+          "short",
+          "static",
+          "strictfp",
+          "super",
+          "switch",
+          "synchronized",
+          "this",
+          "throw",
+          "throws",
+          "transient",
+          "try",
+          "void",
+          "volatile",
+          "while"]
+    literals =
+        [
+          "false",
+          "null",
+          "true"]
diff --git a/src/main/haskell/Hydra/Java/Names.hs b/src/main/haskell/Hydra/Java/Names.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Java/Names.hs
@@ -0,0 +1,120 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Java naming constants and package name utilities
+
+module Hydra.Java.Names where
+
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Classes as Classes
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Java.Syntax as Syntax
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+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.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+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
+
+acceptMethodName :: String
+acceptMethodName = "accept"
+
+applyMethodName :: String
+applyMethodName = "apply"
+
+compareToMethodName :: String
+compareToMethodName = "compareTo"
+
+equalsMethodName :: String
+equalsMethodName = "equals"
+
+getMethodName :: String
+getMethodName = "get"
+
+hashCodeMethodName :: String
+hashCodeMethodName = "hashCode"
+
+-- | The hydra.core package name
+hydraCorePackageName :: Maybe Syntax.PackageName
+hydraCorePackageName =
+    Just (javaPackageName [
+      "hydra",
+      "core"])
+
+-- | The hydra.overlay.java.util package name
+hydraUtilPackageName :: Maybe Syntax.PackageName
+hydraUtilPackageName =
+    Just (javaPackageName [
+      "hydra",
+      "overlay",
+      "java",
+      "util"])
+
+instanceName :: String
+instanceName = "instance"
+
+-- | The java.lang package name
+javaLangPackageName :: Maybe Syntax.PackageName
+javaLangPackageName =
+    Just (javaPackageName [
+      "java",
+      "lang"])
+
+-- | Construct a Java package name from a list of string parts
+javaPackageName :: [String] -> Syntax.PackageName
+javaPackageName parts = Syntax.PackageName (Lists.map (\p -> Syntax.Identifier p) parts)
+
+-- | The java.util.function package name
+javaUtilFunctionPackageName :: Maybe Syntax.PackageName
+javaUtilFunctionPackageName =
+    Just (javaPackageName [
+      "java",
+      "util",
+      "function"])
+
+-- | The java.util package name
+javaUtilPackageName :: Maybe Syntax.PackageName
+javaUtilPackageName =
+    Just (javaPackageName [
+      "java",
+      "util"])
+
+otherInstanceName :: String
+otherInstanceName = "other"
+
+otherwiseMethodName :: String
+otherwiseMethodName = "otherwise"
+
+partialVisitorName :: String
+partialVisitorName = "PartialVisitor"
+
+setMethodName :: String
+setMethodName = "set"
+
+valueFieldName :: String
+valueFieldName = "value"
+
+visitMethodName :: String
+visitMethodName = "visit"
+
+visitorName :: String
+visitorName = "Visitor"
+
+visitorReturnParameter :: String
+visitorReturnParameter = "R"
diff --git a/src/main/haskell/Hydra/Java/Serde.hs b/src/main/haskell/Hydra/Java/Serde.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Java/Serde.hs
@@ -0,0 +1,1325 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Java serializer: converts Java AST to concrete syntax
+
+module Hydra.Java.Serde where
+
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Classes as Classes
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Constants as Constants
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Java.Syntax as Syntax
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Jvm.Serde as Serde
+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Names as Names
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Serialization as Serialization
+import qualified Hydra.Show.Docs as Docs
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+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
+
+additionalBoundToExpr :: Syntax.AdditionalBound -> Ast.Expr
+additionalBoundToExpr ab =
+    Serialization.spaceSep [
+      Serialization.cst "&",
+      (interfaceTypeToExpr (Syntax.unAdditionalBound ab))]
+
+additiveExpressionToExpr :: Syntax.AdditiveExpression -> Ast.Expr
+additiveExpressionToExpr e =
+    case e of
+      Syntax.AdditiveExpressionUnary v0 -> multiplicativeExpressionToExpr v0
+      Syntax.AdditiveExpressionPlus v0 -> Serialization.infixWs "+" (additiveExpressionToExpr (Syntax.additiveExpression_BinaryLhs v0)) (multiplicativeExpressionToExpr (Syntax.additiveExpression_BinaryRhs v0))
+      Syntax.AdditiveExpressionMinus v0 -> Serialization.infixWs "-" (additiveExpressionToExpr (Syntax.additiveExpression_BinaryLhs v0)) (multiplicativeExpressionToExpr (Syntax.additiveExpression_BinaryRhs v0))
+
+ambiguousNameToExpr :: Syntax.AmbiguousName -> Ast.Expr
+ambiguousNameToExpr an = Serialization.dotSep (Lists.map identifierToExpr (Syntax.unAmbiguousName an))
+
+andExpressionToExpr :: Syntax.AndExpression -> Ast.Expr
+andExpressionToExpr ae = Serialization.infixWsList "&" (Lists.map equalityExpressionToExpr (Syntax.unAndExpression ae))
+
+annotatedIdentifierToExpr :: Syntax.AnnotatedIdentifier -> Ast.Expr
+annotatedIdentifierToExpr ai = identifierToExpr (Syntax.annotatedIdentifierIdentifier ai)
+
+annotationToExpr :: Syntax.Annotation -> Ast.Expr
+annotationToExpr ann =
+    case ann of
+      Syntax.AnnotationNormal v0 -> normalAnnotationToExpr v0
+      Syntax.AnnotationMarker v0 -> markerAnnotationToExpr v0
+      Syntax.AnnotationSingleElement v0 -> singleElementAnnotationToExpr v0
+
+annotationTypeDeclarationToExpr :: t0 -> Ast.Expr
+annotationTypeDeclarationToExpr _ = Serialization.cst "STUB:AnnotationInterfaceDeclaration"
+
+arrayAccessToExpr :: t0 -> Ast.Expr
+arrayAccessToExpr _ = Serialization.cst "STUB:ArrayAccess"
+
+arrayCreationExpressionToExpr :: Syntax.ArrayCreationExpression -> Ast.Expr
+arrayCreationExpressionToExpr ace =
+    case ace of
+      Syntax.ArrayCreationExpressionWithoutInitializer_ _ -> Serialization.cst "STUB:ArrayCreationExpression"
+      Syntax.ArrayCreationExpressionWithInitializer_ v0 -> case v0 of
+        Syntax.ArrayCreationExpressionWithInitializerPrimitive v1 ->
+          let pt = Syntax.arrayCreationExpressionWithInitializer_PrimitiveType v1
+              ai = Syntax.arrayCreationExpressionWithInitializer_PrimitiveArray v1
+          in (Serialization.spaceSep [
+            Serialization.cst "new",
+            (Serialization.noSep [
+              primitiveTypeWithAnnotationsToExpr pt,
+              (Serialization.cst "[]")]),
+            (arrayInitializerToExpr ai)])
+        Syntax.ArrayCreationExpressionWithInitializerClassOrInterface _ -> Serialization.cst "STUB:ArrayCreationExpression"
+
+arrayInitializerToExpr :: Syntax.ArrayInitializer -> Ast.Expr
+arrayInitializerToExpr ai =
+
+      let groups = Syntax.unArrayInitializer ai
+      in (Optionals.fromOptional (Serialization.cst "{}") (Optionals.map (\firstGroup -> Logic.ifElse (Equality.equal (Lists.length groups) 1) (Serialization.noSep [
+        Serialization.cst "{",
+        (Serialization.commaSep Serialization.inlineStyle (Lists.map variableInitializerToExpr firstGroup)),
+        (Serialization.cst "}")]) (Serialization.cst "{}")) (Lists.maybeHead groups)))
+
+arrayTypeToExpr :: Syntax.ArrayType -> Ast.Expr
+arrayTypeToExpr at =
+
+      let dims = Syntax.arrayTypeDims at
+          variant = Syntax.arrayTypeVariant at
+          varExpr =
+                  case variant of
+                    Syntax.ArrayType_VariantPrimitive v0 -> primitiveTypeWithAnnotationsToExpr v0
+                    Syntax.ArrayType_VariantClassOrInterface v0 -> classOrInterfaceTypeToExpr v0
+                    Syntax.ArrayType_VariantVariable v0 -> typeVariableToExpr v0
+      in (Serialization.noSep [
+        varExpr,
+        (dimsToExpr dims)])
+
+assertStatementToExpr :: t0 -> Ast.Expr
+assertStatementToExpr _ = Serialization.cst "STUB:AssertStatement"
+
+assignmentExpressionToExpr :: Syntax.AssignmentExpression -> Ast.Expr
+assignmentExpressionToExpr e =
+    case e of
+      Syntax.AssignmentExpressionConditional v0 -> conditionalExpressionToExpr v0
+      Syntax.AssignmentExpressionAssignment v0 -> assignmentToExpr v0
+
+assignmentToExpr :: Syntax.Assignment -> Ast.Expr
+assignmentToExpr a =
+
+      let lhs = Syntax.assignmentLhs a
+          op = Syntax.assignmentOp a
+          rhs = Syntax.assignmentExpression a
+          ctop =
+                  case op of
+                    Syntax.AssignmentOperatorSimple -> "="
+                    Syntax.AssignmentOperatorTimes -> "*="
+                    Syntax.AssignmentOperatorDiv -> "/="
+                    Syntax.AssignmentOperatorMod -> "%="
+                    Syntax.AssignmentOperatorPlus -> "+="
+                    Syntax.AssignmentOperatorMinus -> "-="
+                    Syntax.AssignmentOperatorShiftLeft -> "<<="
+                    Syntax.AssignmentOperatorShiftRight -> ">>="
+                    Syntax.AssignmentOperatorShiftRightZeroFill -> ">>>="
+                    Syntax.AssignmentOperatorAnd -> "&="
+                    Syntax.AssignmentOperatorXor -> "^="
+                    Syntax.AssignmentOperatorOr -> "|="
+      in (Serialization.infixWs ctop (leftHandSideToExpr lhs) (expressionToExpr rhs))
+
+blockStatementToExpr :: Syntax.BlockStatement -> Ast.Expr
+blockStatementToExpr s =
+    case s of
+      Syntax.BlockStatementLocalVariableDeclaration v0 -> localVariableDeclarationStatementToExpr v0
+      Syntax.BlockStatementLocalClassOrInterface v0 -> case v0 of
+        Syntax.LocalClassOrInterfaceDeclarationClass v1 -> classDeclarationToExpr v1
+        Syntax.LocalClassOrInterfaceDeclarationNormalInterface v1 -> interfaceDeclarationToExpr (Syntax.InterfaceDeclarationNormalInterface v1)
+      Syntax.BlockStatementStatement v0 -> statementToExpr v0
+
+blockToExpr :: Syntax.Block -> Ast.Expr
+blockToExpr b =
+    Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.newlineSep (Lists.map blockStatementToExpr (Syntax.unBlock b)))
+
+breakStatementToExpr :: Syntax.BreakStatement -> Ast.Expr
+breakStatementToExpr bs =
+
+      let mlabel = Syntax.unBreakStatement bs
+      in (Serialization.withSemi (Serialization.spaceSep (Optionals.cat [
+        Just (Serialization.cst "break"),
+        (Optionals.map identifierToExpr mlabel)])))
+
+castExpressionLambdaToExpr :: t0 -> Ast.Expr
+castExpressionLambdaToExpr _ = Serialization.cst "STUB:CastExpression_Lambda"
+
+castExpressionNotPlusMinusToExpr :: Syntax.CastExpression_NotPlusMinus -> Ast.Expr
+castExpressionNotPlusMinusToExpr npm =
+
+      let rb = Syntax.castExpression_NotPlusMinusRefAndBounds npm
+          ex = Syntax.castExpression_NotPlusMinusExpression npm
+      in (Serialization.spaceSep [
+        castExpressionRefAndBoundsToExpr rb,
+        (unaryExpressionToExpr ex)])
+
+castExpressionPrimitiveToExpr :: Syntax.CastExpression_Primitive -> Ast.Expr
+castExpressionPrimitiveToExpr cp =
+
+      let pt = Syntax.castExpression_PrimitiveType cp
+          ex = Syntax.castExpression_PrimitiveExpression cp
+      in (Serialization.spaceSep [
+        Serialization.parenList False [
+          primitiveTypeWithAnnotationsToExpr pt],
+        (unaryExpressionToExpr ex)])
+
+castExpressionRefAndBoundsToExpr :: Syntax.CastExpression_RefAndBounds -> Ast.Expr
+castExpressionRefAndBoundsToExpr rab =
+
+      let rt = Syntax.castExpression_RefAndBoundsType rab
+          adds = Syntax.castExpression_RefAndBoundsBounds rab
+      in (Serialization.parenList False [
+        Serialization.spaceSep (Optionals.cat [
+          Just (referenceTypeToExpr rt),
+          (Logic.ifElse (Lists.null adds) Nothing (Just (Serialization.spaceSep (Lists.map additionalBoundToExpr adds))))])])
+
+castExpressionToExpr :: Syntax.CastExpression -> Ast.Expr
+castExpressionToExpr e =
+    case e of
+      Syntax.CastExpressionPrimitive v0 -> castExpressionPrimitiveToExpr v0
+      Syntax.CastExpressionNotPlusMinus v0 -> castExpressionNotPlusMinusToExpr v0
+      Syntax.CastExpressionLambda v0 -> castExpressionLambdaToExpr v0
+
+classBodyDeclarationToExpr :: Syntax.ClassBodyDeclaration -> Ast.Expr
+classBodyDeclarationToExpr d =
+    case d of
+      Syntax.ClassBodyDeclarationClassMember v0 -> classMemberDeclarationToExpr v0
+      Syntax.ClassBodyDeclarationInstanceInitializer v0 -> instanceInitializerToExpr v0
+      Syntax.ClassBodyDeclarationStaticInitializer v0 -> staticInitializerToExpr v0
+      Syntax.ClassBodyDeclarationConstructorDeclaration v0 -> constructorDeclarationToExpr v0
+
+classBodyDeclarationWithCommentsToExpr :: Syntax.ClassBodyDeclarationWithComments -> Ast.Expr
+classBodyDeclarationWithCommentsToExpr cbdwc =
+
+      let d = Syntax.classBodyDeclarationWithCommentsValue cbdwc
+          mc = Syntax.classBodyDeclarationWithCommentsComments cbdwc
+      in (withComments mc (classBodyDeclarationToExpr d))
+
+classBodyToExpr :: Syntax.ClassBody -> Ast.Expr
+classBodyToExpr cb =
+    Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.doubleNewlineSep (Lists.map classBodyDeclarationWithCommentsToExpr (Syntax.unClassBody cb)))
+
+classDeclarationToExpr :: Syntax.ClassDeclaration -> Ast.Expr
+classDeclarationToExpr d =
+    case d of
+      Syntax.ClassDeclarationNormal v0 -> normalClassDeclarationToExpr v0
+      Syntax.ClassDeclarationEnum v0 -> enumDeclarationToExpr v0
+
+classInstanceCreationExpressionQualifierToExpr :: Syntax.ClassInstanceCreationExpression_Qualifier -> Ast.Expr
+classInstanceCreationExpressionQualifierToExpr q =
+    case q of
+      Syntax.ClassInstanceCreationExpression_QualifierExpression v0 -> expressionNameToExpr v0
+      Syntax.ClassInstanceCreationExpression_QualifierPrimary v0 -> primaryToExpr v0
+
+classInstanceCreationExpressionToExpr :: Syntax.ClassInstanceCreationExpression -> Ast.Expr
+classInstanceCreationExpressionToExpr cice =
+
+      let mqual = Syntax.classInstanceCreationExpressionQualifier cice
+          e = Syntax.classInstanceCreationExpressionExpression cice
+      in (Optionals.cases mqual (unqualifiedClassInstanceCreationExpressionToExpr e) (\q -> Serialization.dotSep [
+        classInstanceCreationExpressionQualifierToExpr q,
+        (unqualifiedClassInstanceCreationExpressionToExpr e)]))
+
+classLiteralToExpr :: t0 -> Ast.Expr
+classLiteralToExpr _ = Serialization.cst "STUB:ClassLiteral"
+
+classMemberDeclarationToExpr :: Syntax.ClassMemberDeclaration -> Ast.Expr
+classMemberDeclarationToExpr d =
+    case d of
+      Syntax.ClassMemberDeclarationField v0 -> fieldDeclarationToExpr v0
+      Syntax.ClassMemberDeclarationMethod v0 -> methodDeclarationToExpr v0
+      Syntax.ClassMemberDeclarationClass v0 -> classDeclarationToExpr v0
+      Syntax.ClassMemberDeclarationInterface v0 -> interfaceDeclarationToExpr v0
+      Syntax.ClassMemberDeclarationNone -> Serialization.cst ";"
+
+classModifierToExpr :: Syntax.ClassModifier -> Ast.Expr
+classModifierToExpr m =
+    case m of
+      Syntax.ClassModifierAnnotation v0 -> annotationToExpr v0
+      Syntax.ClassModifierPublic -> Serialization.cst "public"
+      Syntax.ClassModifierProtected -> Serialization.cst "protected"
+      Syntax.ClassModifierPrivate -> Serialization.cst "private"
+      Syntax.ClassModifierAbstract -> Serialization.cst "abstract"
+      Syntax.ClassModifierStatic -> Serialization.cst "static"
+      Syntax.ClassModifierFinal -> Serialization.cst "final"
+      Syntax.ClassModifierStrictfp -> Serialization.cst "strictfp"
+
+classOrInterfaceTypeToExpr :: Syntax.ClassOrInterfaceType -> Ast.Expr
+classOrInterfaceTypeToExpr cit =
+    case cit of
+      Syntax.ClassOrInterfaceTypeClass v0 -> classTypeToExpr v0
+      Syntax.ClassOrInterfaceTypeInterface v0 -> interfaceTypeToExpr v0
+
+classOrInterfaceTypeToInstantiateToExpr :: Syntax.ClassOrInterfaceTypeToInstantiate -> Ast.Expr
+classOrInterfaceTypeToInstantiateToExpr coitti =
+
+      let ids = Syntax.classOrInterfaceTypeToInstantiateIdentifiers coitti
+          margs = Syntax.classOrInterfaceTypeToInstantiateTypeArguments coitti
+      in (Serialization.noSep (Optionals.cat [
+        Just (Serialization.dotSep (Lists.map annotatedIdentifierToExpr ids)),
+        (Optionals.map typeArgumentsOrDiamondToExpr margs)]))
+
+classTypeToExpr :: Syntax.ClassType -> Ast.Expr
+classTypeToExpr ct =
+
+      let anns = Syntax.classTypeAnnotations ct
+          qual = Syntax.classTypeQualifier ct
+          id = Syntax.classTypeIdentifier ct
+          args = Syntax.classTypeArguments ct
+          qualifiedId =
+                  case qual of
+                    Syntax.ClassTypeQualifierNone -> typeIdentifierToExpr id
+                    Syntax.ClassTypeQualifierPackage v0 -> Serialization.dotSep [
+                      packageNameToExpr v0,
+                      (typeIdentifierToExpr id)]
+                    Syntax.ClassTypeQualifierParent v0 -> Serialization.dotSep [
+                      classOrInterfaceTypeToExpr v0,
+                      (typeIdentifierToExpr id)]
+      in (Serialization.noSep (Optionals.cat [
+        Just (Serialization.spaceSep (Optionals.cat [
+          Logic.ifElse (Lists.null anns) Nothing (Just (Serialization.commaSep Serialization.inlineStyle (Lists.map annotationToExpr anns))),
+          (Just qualifiedId)])),
+        (Logic.ifElse (Lists.null args) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map typeArgumentToExpr args))))]))
+
+compilationUnitToExpr :: Syntax.CompilationUnit -> Ast.Expr
+compilationUnitToExpr u =
+    case u of
+      Syntax.CompilationUnitOrdinary v0 ->
+        let mpkg = Syntax.ordinaryCompilationUnitPackage v0
+            imports = Syntax.ordinaryCompilationUnitImports v0
+            types = Syntax.ordinaryCompilationUnitTypes v0
+            warning = Just (singleLineComment Constants.warningAutoGeneratedFile)
+            pkgSec = Optionals.map packageDeclarationToExpr mpkg
+            importsSec =
+                    Logic.ifElse (Lists.null imports) Nothing (Just (Serialization.newlineSep (Lists.map importDeclarationToExpr imports)))
+            typesSec =
+                    Logic.ifElse (Lists.null types) Nothing (Just (Serialization.doubleNewlineSep (Lists.map typeDeclarationWithCommentsToExpr types)))
+        in (Serialization.doubleNewlineSep (Optionals.cat [
+          warning,
+          pkgSec,
+          importsSec,
+          typesSec]))
+
+conditionalAndExpressionToExpr :: Syntax.ConditionalAndExpression -> Ast.Expr
+conditionalAndExpressionToExpr cae =
+    Serialization.infixWsList "&&" (Lists.map inclusiveOrExpressionToExpr (Syntax.unConditionalAndExpression cae))
+
+conditionalExpressionTernaryCondToExpr :: t0 -> Ast.Expr
+conditionalExpressionTernaryCondToExpr _ = Serialization.cst "STUB:ConditionalExpression_TernaryCond"
+
+conditionalExpressionTernaryLambdaToExpr :: t0 -> Ast.Expr
+conditionalExpressionTernaryLambdaToExpr _ = Serialization.cst "STUB:ConditionalExpression_TernaryLambda"
+
+conditionalExpressionToExpr :: Syntax.ConditionalExpression -> Ast.Expr
+conditionalExpressionToExpr c =
+    case c of
+      Syntax.ConditionalExpressionSimple v0 -> conditionalOrExpressionToExpr v0
+      Syntax.ConditionalExpressionTernaryCond v0 -> conditionalExpressionTernaryCondToExpr v0
+      Syntax.ConditionalExpressionTernaryLambda v0 -> conditionalExpressionTernaryLambdaToExpr v0
+
+conditionalOrExpressionToExpr :: Syntax.ConditionalOrExpression -> Ast.Expr
+conditionalOrExpressionToExpr coe =
+    Serialization.infixWsList "||" (Lists.map conditionalAndExpressionToExpr (Syntax.unConditionalOrExpression coe))
+
+constantDeclarationToExpr :: Syntax.ConstantDeclaration -> Ast.Expr
+constantDeclarationToExpr cd =
+
+      let mods = Syntax.constantDeclarationModifiers cd
+          typ = Syntax.constantDeclarationType cd
+          vars = Syntax.constantDeclarationVariables cd
+      in (Serialization.withSemi (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map constantModifierToExpr mods))),
+        (Just (unannTypeToExpr typ)),
+        (Just (Serialization.commaSep Serialization.inlineStyle (Lists.map variableDeclaratorToExpr vars)))])))
+
+constantModifierToExpr :: t0 -> Ast.Expr
+constantModifierToExpr _ = Serialization.cst "STUB:ConstantModifier"
+
+constructorBodyToExpr :: Syntax.ConstructorBody -> Ast.Expr
+constructorBodyToExpr cb =
+
+      let minvoc = Syntax.constructorBodyInvocation cb
+          stmts = Syntax.constructorBodyStatements cb
+      in (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.doubleNewlineSep (Optionals.cat [
+        Optionals.map explicitConstructorInvocationToExpr minvoc,
+        (Just (Serialization.newlineSep (Lists.map blockStatementToExpr stmts)))])))
+
+constructorDeclarationToExpr :: Syntax.ConstructorDeclaration -> Ast.Expr
+constructorDeclarationToExpr cd =
+
+      let mods = Syntax.constructorDeclarationModifiers cd
+          cons = Syntax.constructorDeclarationConstructor cd
+          mthrows = Syntax.constructorDeclarationThrows cd
+          body = Syntax.constructorDeclarationBody cd
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map constructorModifierToExpr mods))),
+        (Just (constructorDeclaratorToExpr cons)),
+        (Optionals.map throwsToExpr mthrows),
+        (Just (constructorBodyToExpr body))]))
+
+constructorDeclaratorToExpr :: Syntax.ConstructorDeclarator -> Ast.Expr
+constructorDeclaratorToExpr cd =
+
+      let tparams = Syntax.constructorDeclaratorParameters cd
+          name = Syntax.constructorDeclaratorName cd
+          fparams = Syntax.constructorDeclaratorFormalParameters cd
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null tparams) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map typeParameterToExpr tparams))),
+        (Just (simpleTypeNameToExpr name)),
+        (Just (Serialization.parenListAdaptive (Lists.map formalParameterToExpr fparams)))]))
+
+constructorModifierToExpr :: Syntax.ConstructorModifier -> Ast.Expr
+constructorModifierToExpr m =
+    case m of
+      Syntax.ConstructorModifierAnnotation v0 -> annotationToExpr v0
+      Syntax.ConstructorModifierPublic -> Serialization.cst "public"
+      Syntax.ConstructorModifierProtected -> Serialization.cst "protected"
+      Syntax.ConstructorModifierPrivate -> Serialization.cst "private"
+
+continueStatementToExpr :: Syntax.ContinueStatement -> Ast.Expr
+continueStatementToExpr cs =
+
+      let mlabel = Syntax.unContinueStatement cs
+      in (Serialization.withSemi (Serialization.spaceSep (Optionals.cat [
+        Just (Serialization.cst "continue"),
+        (Optionals.map identifierToExpr mlabel)])))
+
+dimsToExpr :: Syntax.Dims -> Ast.Expr
+dimsToExpr d = Serialization.noSep (Lists.map (\_ -> Serialization.cst "[]") (Syntax.unDims d))
+
+doStatementToExpr :: t0 -> Ast.Expr
+doStatementToExpr _ = Serialization.cst "STUB:DoStatement"
+
+elementValuePairToExpr :: Syntax.ElementValuePair -> Ast.Expr
+elementValuePairToExpr evp =
+
+      let k = Syntax.elementValuePairKey evp
+          v = Syntax.elementValuePairValue evp
+      in (Serialization.infixWs "=" (identifierToExpr k) (elementValueToExpr v))
+
+elementValueToExpr :: Syntax.ElementValue -> Ast.Expr
+elementValueToExpr ev =
+    case ev of
+      Syntax.ElementValueConditionalExpression v0 -> conditionalExpressionToExpr v0
+      Syntax.ElementValueElementValueArrayInitializer v0 -> Serialization.commaSep Serialization.inlineStyle (Lists.map elementValueToExpr (Syntax.unElementValueArrayInitializer v0))
+      Syntax.ElementValueAnnotation v0 -> annotationToExpr v0
+
+enumDeclarationToExpr :: t0 -> Ast.Expr
+enumDeclarationToExpr _ = Serialization.cst "STUB:EnumDeclaration"
+
+equalityExpressionToExpr :: Syntax.EqualityExpression -> Ast.Expr
+equalityExpressionToExpr e =
+    case e of
+      Syntax.EqualityExpressionUnary v0 -> relationalExpressionToExpr v0
+      Syntax.EqualityExpressionEqual v0 -> Serialization.infixWs "==" (equalityExpressionToExpr (Syntax.equalityExpression_BinaryLhs v0)) (relationalExpressionToExpr (Syntax.equalityExpression_BinaryRhs v0))
+      Syntax.EqualityExpressionNotEqual v0 -> Serialization.infixWs "!=" (equalityExpressionToExpr (Syntax.equalityExpression_BinaryLhs v0)) (relationalExpressionToExpr (Syntax.equalityExpression_BinaryRhs v0))
+
+exclusiveOrExpressionToExpr :: Syntax.ExclusiveOrExpression -> Ast.Expr
+exclusiveOrExpressionToExpr eoe =
+    Serialization.infixWsList "^" (Lists.map andExpressionToExpr (Syntax.unExclusiveOrExpression eoe))
+
+explicitConstructorInvocationToExpr :: t0 -> Ast.Expr
+explicitConstructorInvocationToExpr _ = Serialization.cst "STUB:ExplicitConstructorInvocation"
+
+expressionNameToExpr :: Syntax.ExpressionName -> Ast.Expr
+expressionNameToExpr en =
+
+      let mqual = Syntax.expressionNameQualifier en
+          id = Syntax.expressionNameIdentifier en
+      in (Serialization.dotSep (Optionals.cat [
+        Optionals.map ambiguousNameToExpr mqual,
+        (Just (identifierToExpr id))]))
+
+expressionStatementToExpr :: Syntax.ExpressionStatement -> Ast.Expr
+expressionStatementToExpr es = Serialization.withSemi (statementExpressionToExpr (Syntax.unExpressionStatement es))
+
+expressionToExpr :: Syntax.Expression -> Ast.Expr
+expressionToExpr e =
+    case e of
+      Syntax.ExpressionLambda v0 -> lambdaExpressionToExpr v0
+      Syntax.ExpressionAssignment v0 -> assignmentExpressionToExpr v0
+
+fieldAccessToExpr :: Syntax.FieldAccess -> Ast.Expr
+fieldAccessToExpr fa =
+
+      let qual = Syntax.fieldAccessQualifier fa
+          id = Syntax.fieldAccessIdentifier fa
+      in case qual of
+        Syntax.FieldAccess_QualifierPrimary v0 -> Serialization.dotSep [
+          primaryToExpr v0,
+          (identifierToExpr id)]
+        Syntax.FieldAccess_QualifierSuper -> Serialization.dotSep [
+          Serialization.cst "super",
+          (identifierToExpr id)]
+        Syntax.FieldAccess_QualifierTyped v0 -> Serialization.dotSep [
+          typeNameToExpr v0,
+          (Serialization.cst "super"),
+          (identifierToExpr id)]
+
+fieldDeclarationToExpr :: Syntax.FieldDeclaration -> Ast.Expr
+fieldDeclarationToExpr fd =
+
+      let mods = Syntax.fieldDeclarationModifiers fd
+          typ = Syntax.fieldDeclarationUnannType fd
+          vars = Syntax.fieldDeclarationVariableDeclarators fd
+      in (Serialization.withSemi (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map fieldModifierToExpr mods))),
+        (Just (unannTypeToExpr typ)),
+        (Just (Serialization.commaSep Serialization.inlineStyle (Lists.map variableDeclaratorToExpr vars)))])))
+
+fieldModifierToExpr :: Syntax.FieldModifier -> Ast.Expr
+fieldModifierToExpr m =
+    case m of
+      Syntax.FieldModifierAnnotation v0 -> annotationToExpr v0
+      Syntax.FieldModifierPublic -> Serialization.cst "public"
+      Syntax.FieldModifierProtected -> Serialization.cst "protected"
+      Syntax.FieldModifierPrivate -> Serialization.cst "private"
+      Syntax.FieldModifierStatic -> Serialization.cst "static"
+      Syntax.FieldModifierFinal -> Serialization.cst "final"
+      Syntax.FieldModifierTransient -> Serialization.cst "transient"
+      Syntax.FieldModifierVolatile -> Serialization.cst "volatile"
+
+floatingPointLiteralToExpr :: Syntax.FloatingPointLiteral -> Ast.Expr
+floatingPointLiteralToExpr fl =
+    Serialization.cst (javaFloatLiteralText (Literals.showFloat64 (Syntax.unFloatingPointLiteral fl)))
+
+floatingPointTypeToExpr :: Syntax.FloatingPointType -> Ast.Expr
+floatingPointTypeToExpr ft =
+    case ft of
+      Syntax.FloatingPointTypeFloat -> Serialization.cst "float"
+      Syntax.FloatingPointTypeDouble -> Serialization.cst "double"
+
+forStatementToExpr :: t0 -> Ast.Expr
+forStatementToExpr _ = Serialization.cst "STUB:ForStatement"
+
+formalParameterSimpleToExpr :: Syntax.FormalParameter_Simple -> Ast.Expr
+formalParameterSimpleToExpr fps =
+
+      let mods = Syntax.formalParameter_SimpleModifiers fps
+          typ = Syntax.formalParameter_SimpleType fps
+          id = Syntax.formalParameter_SimpleId fps
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map variableModifierToExpr mods))),
+        (Just (unannTypeToExpr typ)),
+        (Just (variableDeclaratorIdToExpr id))]))
+
+formalParameterToExpr :: Syntax.FormalParameter -> Ast.Expr
+formalParameterToExpr p =
+    case p of
+      Syntax.FormalParameterSimple v0 -> formalParameterSimpleToExpr v0
+      Syntax.FormalParameterVariableArity v0 -> variableArityParameterToExpr v0
+
+identifierToExpr :: Syntax.Identifier -> Ast.Expr
+identifierToExpr id = Serialization.cst (Syntax.unIdentifier id)
+
+ifThenElseStatementToExpr :: t0 -> Ast.Expr
+ifThenElseStatementToExpr _ = Serialization.cst "STUB:IfThenElseStatement"
+
+ifThenStatementToExpr :: Syntax.IfThenStatement -> Ast.Expr
+ifThenStatementToExpr its =
+
+      let cond = Syntax.ifThenStatementExpression its
+          thn = Syntax.ifThenStatementStatement its
+      in (Serialization.spaceSep [
+        Serialization.cst "if",
+        (Serialization.parenList False [
+          expressionToExpr cond]),
+        (Serialization.curlyBlock Serialization.fullBlockStyle (statementToExpr thn))])
+
+importDeclarationToExpr :: Syntax.ImportDeclaration -> Ast.Expr
+importDeclarationToExpr imp =
+    case imp of
+      Syntax.ImportDeclarationSingleType v0 -> Serialization.withSemi (Serialization.spaceSep [
+        Serialization.cst "import",
+        (typeNameToExpr (Syntax.unSingleTypeImportDeclaration v0))])
+      Syntax.ImportDeclarationTypeImportOnDemand _ -> Serialization.cst "STUB:ImportDeclarationTypeImportOnDemand"
+      Syntax.ImportDeclarationSingleStaticImport _ -> Serialization.cst "STUB:ImportDeclarationSingleStaticImport"
+      Syntax.ImportDeclarationStaticImportOnDemand _ -> Serialization.cst "STUB:ImportDeclarationStaticImportOnDemand"
+
+inclusiveOrExpressionToExpr :: Syntax.InclusiveOrExpression -> Ast.Expr
+inclusiveOrExpressionToExpr ioe =
+    Serialization.infixWsList "|" (Lists.map exclusiveOrExpressionToExpr (Syntax.unInclusiveOrExpression ioe))
+
+instanceInitializerToExpr :: t0 -> Ast.Expr
+instanceInitializerToExpr _ = Serialization.cst "STUB:InstanceInitializer"
+
+integerLiteralToExpr :: Syntax.IntegerLiteral -> Ast.Expr
+integerLiteralToExpr il =
+
+      let i = Syntax.unIntegerLiteral il
+          suffix = Logic.ifElse (Logic.or (Equality.gt i 2147483647) (Equality.lt i (-2147483648))) "L" ""
+      in (Serialization.cst (Strings.cat2 (Literals.showBigint i) suffix))
+
+integralTypeToExpr :: Syntax.IntegralType -> Ast.Expr
+integralTypeToExpr t =
+    case t of
+      Syntax.IntegralTypeByte -> Serialization.cst "byte"
+      Syntax.IntegralTypeShort -> Serialization.cst "short"
+      Syntax.IntegralTypeInt -> Serialization.cst "int"
+      Syntax.IntegralTypeLong -> Serialization.cst "long"
+      Syntax.IntegralTypeChar -> Serialization.cst "char"
+
+interfaceBodyToExpr :: Syntax.InterfaceBody -> Ast.Expr
+interfaceBodyToExpr ib =
+    Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.doubleNewlineSep (Lists.map interfaceMemberDeclarationWithCommentsToExpr (Syntax.unInterfaceBody ib)))
+
+interfaceDeclarationToExpr :: Syntax.InterfaceDeclaration -> Ast.Expr
+interfaceDeclarationToExpr d =
+    case d of
+      Syntax.InterfaceDeclarationNormalInterface v0 -> normalInterfaceDeclarationToExpr v0
+      Syntax.InterfaceDeclarationAnnotationInterface v0 -> annotationTypeDeclarationToExpr v0
+
+interfaceMemberDeclarationToExpr :: Syntax.InterfaceMemberDeclaration -> Ast.Expr
+interfaceMemberDeclarationToExpr d =
+    case d of
+      Syntax.InterfaceMemberDeclarationConstant v0 -> constantDeclarationToExpr v0
+      Syntax.InterfaceMemberDeclarationInterfaceMethod v0 -> interfaceMethodDeclarationToExpr v0
+      Syntax.InterfaceMemberDeclarationClass v0 -> classDeclarationToExpr v0
+      Syntax.InterfaceMemberDeclarationInterface v0 -> interfaceDeclarationToExpr v0
+
+interfaceMemberDeclarationWithCommentsToExpr :: Syntax.InterfaceMemberDeclarationWithComments -> Ast.Expr
+interfaceMemberDeclarationWithCommentsToExpr imdwc =
+
+      let d = Syntax.interfaceMemberDeclarationWithCommentsValue imdwc
+          mc = Syntax.interfaceMemberDeclarationWithCommentsComments imdwc
+      in (withComments mc (interfaceMemberDeclarationToExpr d))
+
+interfaceMethodDeclarationToExpr :: Syntax.InterfaceMethodDeclaration -> Ast.Expr
+interfaceMethodDeclarationToExpr imd =
+
+      let mods = Syntax.interfaceMethodDeclarationModifiers imd
+          header = Syntax.interfaceMethodDeclarationHeader imd
+          body = Syntax.interfaceMethodDeclarationBody imd
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map interfaceMethodModifierToExpr mods))),
+        (Just (methodHeaderToExpr header)),
+        (Just (methodBodyToExpr body))]))
+
+interfaceMethodModifierToExpr :: Syntax.InterfaceMethodModifier -> Ast.Expr
+interfaceMethodModifierToExpr m =
+    case m of
+      Syntax.InterfaceMethodModifierAnnotation v0 -> annotationToExpr v0
+      Syntax.InterfaceMethodModifierPublic -> Serialization.cst "public"
+      Syntax.InterfaceMethodModifierPrivate -> Serialization.cst "private"
+      Syntax.InterfaceMethodModifierAbstract -> Serialization.cst "abstract"
+      Syntax.InterfaceMethodModifierDefault -> Serialization.cst "default"
+      Syntax.InterfaceMethodModifierStatic -> Serialization.cst "static"
+      Syntax.InterfaceMethodModifierStrictfp -> Serialization.cst "strictfp"
+
+interfaceModifierToExpr :: Syntax.InterfaceModifier -> Ast.Expr
+interfaceModifierToExpr m =
+    case m of
+      Syntax.InterfaceModifierAnnotation v0 -> annotationToExpr v0
+      Syntax.InterfaceModifierPublic -> Serialization.cst "public"
+      Syntax.InterfaceModifierProtected -> Serialization.cst "protected"
+      Syntax.InterfaceModifierPrivate -> Serialization.cst "private"
+      Syntax.InterfaceModifierAbstract -> Serialization.cst "abstract"
+      Syntax.InterfaceModifierStatic -> Serialization.cst "static"
+      Syntax.InterfaceModifierStrictfp -> Serialization.cst "strictfp"
+
+interfaceTypeToExpr :: Syntax.InterfaceType -> Ast.Expr
+interfaceTypeToExpr it = classTypeToExpr (Syntax.unInterfaceType it)
+
+-- | Render a hydra.packaging.EntityReference as Javadoc link syntax
+javaDocEntityRef :: Packaging.EntityReference -> String
+javaDocEntityRef ref =
+    case ref of
+      Packaging.EntityReferenceDefinition v0 -> Strings.cat2 "{@code " (Strings.cat2 (case v0 of
+        Packaging.DefinitionReferencePrimitive v1 -> Names.localNameOf v1
+        Packaging.DefinitionReferenceTerm v1 -> Names.localNameOf v1
+        Packaging.DefinitionReferenceType v1 -> Names.localNameOf v1) "}")
+      Packaging.EntityReferenceModule v0 -> Strings.cat2 "" (Packaging.unModuleName v0)
+      Packaging.EntityReferencePackage v0 -> Strings.cat2 "" (Packaging.unPackageName v0)
+      Packaging.EntityReferenceTermExpr v0 -> Strings.cat2 "{@code " (Strings.cat2 v0 "}")
+      Packaging.EntityReferenceTypeExpr v0 -> Strings.cat2 "{@code " (Strings.cat2 v0 "}")
+
+javaFloatLiteralText :: String -> String
+javaFloatLiteralText s =
+    Logic.ifElse (Equality.equal s "NaN") "Double.NaN" (Logic.ifElse (Equality.equal s "Infinity") "Double.POSITIVE_INFINITY" (Logic.ifElse (Equality.equal s "-Infinity") "Double.NEGATIVE_INFINITY" s))
+
+labeledStatementToExpr :: t0 -> Ast.Expr
+labeledStatementToExpr _ = Serialization.cst "STUB:LabeledStatement"
+
+lambdaBodyToExpr :: Syntax.LambdaBody -> Ast.Expr
+lambdaBodyToExpr b =
+    case b of
+      Syntax.LambdaBodyExpression v0 -> expressionToExpr v0
+      Syntax.LambdaBodyBlock v0 -> blockToExpr v0
+
+lambdaExpressionToExpr :: Syntax.LambdaExpression -> Ast.Expr
+lambdaExpressionToExpr le =
+
+      let params = Syntax.lambdaExpressionParameters le
+          body = Syntax.lambdaExpressionBody le
+      in (Serialization.infixWs "->" (lambdaParametersToExpr params) (lambdaBodyToExpr body))
+
+lambdaParametersToExpr :: Syntax.LambdaParameters -> Ast.Expr
+lambdaParametersToExpr p =
+    case p of
+      Syntax.LambdaParametersTuple v0 -> Serialization.parenList False (Lists.map lambdaParametersToExpr v0)
+      Syntax.LambdaParametersSingle v0 -> identifierToExpr v0
+
+leftHandSideToExpr :: Syntax.LeftHandSide -> Ast.Expr
+leftHandSideToExpr lhs =
+    case lhs of
+      Syntax.LeftHandSideExpressionName v0 -> expressionNameToExpr v0
+      Syntax.LeftHandSideFieldAccess v0 -> fieldAccessToExpr v0
+      Syntax.LeftHandSideArrayAccess v0 -> arrayAccessToExpr v0
+
+literalToExpr :: Syntax.Literal -> Ast.Expr
+literalToExpr l =
+    case l of
+      Syntax.LiteralNull -> Serialization.cst "null"
+      Syntax.LiteralInteger v0 -> integerLiteralToExpr v0
+      Syntax.LiteralFloatingPoint v0 -> floatingPointLiteralToExpr v0
+      Syntax.LiteralBoolean v0 -> Serialization.cst (Logic.ifElse v0 "true" "false")
+      Syntax.LiteralCharacter v0 ->
+        let ci = Literals.bigintToInt32 (Literals.uint16ToBigint v0)
+        in (Serialization.cst (Strings.cat2 "'" (Strings.cat2 (Logic.ifElse (Equality.equal ci 39) "\\'" (Logic.ifElse (Equality.equal ci 92) "\\\\" (Logic.ifElse (Equality.equal ci 10) "\\n" (Logic.ifElse (Equality.equal ci 13) "\\r" (Logic.ifElse (Equality.equal ci 9) "\\t" (Logic.ifElse (Logic.and (Equality.gte ci 32) (Equality.lt ci 127)) (Strings.fromList [
+          ci]) (Serde.javaUnicodeEscape ci))))))) "'")))
+      Syntax.LiteralString v0 -> stringLiteralToExpr v0
+
+localNameToExpr :: Syntax.LocalVariableType -> Ast.Expr
+localNameToExpr t =
+    case t of
+      Syntax.LocalVariableTypeType v0 -> unannTypeToExpr v0
+      Syntax.LocalVariableTypeVar -> Serialization.cst "var"
+
+localVariableDeclarationStatementToExpr :: Syntax.LocalVariableDeclarationStatement -> Ast.Expr
+localVariableDeclarationStatementToExpr lvds =
+    Serialization.withSemi (localVariableDeclarationToExpr (Syntax.unLocalVariableDeclarationStatement lvds))
+
+localVariableDeclarationToExpr :: Syntax.LocalVariableDeclaration -> Ast.Expr
+localVariableDeclarationToExpr lvd =
+
+      let mods = Syntax.localVariableDeclarationModifiers lvd
+          t = Syntax.localVariableDeclarationType lvd
+          decls = Syntax.localVariableDeclarationDeclarators lvd
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map variableModifierToExpr mods))),
+        (Just (localNameToExpr t)),
+        (Just (Serialization.commaSep Serialization.inlineStyle (Lists.map variableDeclaratorToExpr decls)))]))
+
+markerAnnotationToExpr :: Syntax.MarkerAnnotation -> Ast.Expr
+markerAnnotationToExpr ma = Serialization.prefix "@" (typeNameToExpr (Syntax.unMarkerAnnotation ma))
+
+methodBodyToExpr :: Syntax.MethodBody -> Ast.Expr
+methodBodyToExpr b =
+    case b of
+      Syntax.MethodBodyBlock v0 -> blockToExpr v0
+      Syntax.MethodBodyNone -> Serialization.cst ";"
+
+methodDeclarationToExpr :: Syntax.MethodDeclaration -> Ast.Expr
+methodDeclarationToExpr md =
+
+      let anns = Syntax.methodDeclarationAnnotations md
+          mods = Syntax.methodDeclarationModifiers md
+          header = Syntax.methodDeclarationHeader md
+          body = Syntax.methodDeclarationBody md
+          headerAndBody =
+                  Serialization.spaceSep (Optionals.cat [
+                    Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map methodModifierToExpr mods))),
+                    (Just (methodHeaderToExpr header)),
+                    (Just (methodBodyToExpr body))])
+      in (Serialization.newlineSep (Optionals.cat [
+        Logic.ifElse (Lists.null anns) Nothing (Just (Serialization.newlineSep (Lists.map annotationToExpr anns))),
+        (Just headerAndBody)]))
+
+methodDeclaratorToExpr :: Syntax.MethodDeclarator -> Ast.Expr
+methodDeclaratorToExpr md =
+
+      let id = Syntax.methodDeclaratorIdentifier md
+          params = Syntax.methodDeclaratorFormalParameters md
+      in (Serialization.noSep [
+        identifierToExpr id,
+        (Serialization.parenListAdaptive (Lists.map formalParameterToExpr params))])
+
+methodHeaderToExpr :: Syntax.MethodHeader -> Ast.Expr
+methodHeaderToExpr mh =
+
+      let params = Syntax.methodHeaderParameters mh
+          result = Syntax.methodHeaderResult mh
+          decl = Syntax.methodHeaderDeclarator mh
+          mthrows = Syntax.methodHeaderThrows mh
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null params) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map typeParameterToExpr params))),
+        (Just (resultToExpr result)),
+        (Just (methodDeclaratorToExpr decl)),
+        (Optionals.map throwsToExpr mthrows)]))
+
+methodInvocationToExpr :: Syntax.MethodInvocation -> Ast.Expr
+methodInvocationToExpr mi =
+
+      let header = Syntax.methodInvocationHeader mi
+          args = Syntax.methodInvocationArguments mi
+          argSec = Serialization.parenListAdaptive (Lists.map expressionToExpr args)
+          headerSec =
+                  case header of
+                    Syntax.MethodInvocation_HeaderSimple v0 -> methodNameToExpr v0
+                    Syntax.MethodInvocation_HeaderComplex v0 ->
+                      let cvar = Syntax.methodInvocation_ComplexVariant v0
+                          targs = Syntax.methodInvocation_ComplexTypeArguments v0
+                          cid = Syntax.methodInvocation_ComplexIdentifier v0
+                          idSec =
+                                  Serialization.noSep (Optionals.cat [
+                                    Logic.ifElse (Lists.null targs) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map typeArgumentToExpr targs))),
+                                    (Just (identifierToExpr cid))])
+                      in case cvar of
+                        Syntax.MethodInvocation_VariantType v1 -> Serialization.dotSep [
+                          typeNameToExpr v1,
+                          idSec]
+                        Syntax.MethodInvocation_VariantExpression v1 -> Serialization.dotSep [
+                          expressionNameToExpr v1,
+                          idSec]
+                        Syntax.MethodInvocation_VariantPrimary v1 -> Serialization.dotSep [
+                          primaryToExpr v1,
+                          idSec]
+                        Syntax.MethodInvocation_VariantSuper -> Serialization.dotSep [
+                          Serialization.cst "super",
+                          idSec]
+                        Syntax.MethodInvocation_VariantTypeSuper v1 -> Serialization.dotSep [
+                          typeNameToExpr v1,
+                          (Serialization.cst "super"),
+                          idSec]
+      in (Serialization.noSep [
+        headerSec,
+        argSec])
+
+methodModifierToExpr :: Syntax.MethodModifier -> Ast.Expr
+methodModifierToExpr m =
+    case m of
+      Syntax.MethodModifierAnnotation v0 -> annotationToExpr v0
+      Syntax.MethodModifierPublic -> Serialization.cst "public"
+      Syntax.MethodModifierProtected -> Serialization.cst "protected"
+      Syntax.MethodModifierPrivate -> Serialization.cst "private"
+      Syntax.MethodModifierAbstract -> Serialization.cst "abstract"
+      Syntax.MethodModifierStatic -> Serialization.cst "static"
+      Syntax.MethodModifierFinal -> Serialization.cst "final"
+      Syntax.MethodModifierSynchronized -> Serialization.cst "synchronized"
+      Syntax.MethodModifierNative -> Serialization.cst "native"
+      Syntax.MethodModifierStrictfp -> Serialization.cst "strictfp"
+
+methodNameToExpr :: Syntax.MethodName -> Ast.Expr
+methodNameToExpr mn = identifierToExpr (Syntax.unMethodName mn)
+
+methodReferenceToExpr :: t0 -> Ast.Expr
+methodReferenceToExpr _ = Serialization.cst "STUB:MethodReference"
+
+multiplicativeExpressionToExpr :: Syntax.MultiplicativeExpression -> Ast.Expr
+multiplicativeExpressionToExpr e =
+    case e of
+      Syntax.MultiplicativeExpressionUnary v0 -> unaryExpressionToExpr v0
+      Syntax.MultiplicativeExpressionTimes v0 -> Serialization.infixWs "*" (multiplicativeExpressionToExpr (Syntax.multiplicativeExpression_BinaryLhs v0)) (unaryExpressionToExpr (Syntax.multiplicativeExpression_BinaryRhs v0))
+      Syntax.MultiplicativeExpressionDivide v0 -> Serialization.infixWs "/" (multiplicativeExpressionToExpr (Syntax.multiplicativeExpression_BinaryLhs v0)) (unaryExpressionToExpr (Syntax.multiplicativeExpression_BinaryRhs v0))
+      Syntax.MultiplicativeExpressionMod v0 -> Serialization.infixWs "%" (multiplicativeExpressionToExpr (Syntax.multiplicativeExpression_BinaryLhs v0)) (unaryExpressionToExpr (Syntax.multiplicativeExpression_BinaryRhs v0))
+
+normalAnnotationToExpr :: Syntax.NormalAnnotation -> Ast.Expr
+normalAnnotationToExpr na =
+
+      let tname = Syntax.normalAnnotationTypeName na
+          pairs = Syntax.normalAnnotationPairs na
+      in (Serialization.prefix "@" (Serialization.noSep [
+        typeNameToExpr tname,
+        (Serialization.commaSep Serialization.inlineStyle (Lists.map elementValuePairToExpr pairs))]))
+
+normalClassDeclarationToExpr :: Syntax.NormalClassDeclaration -> Ast.Expr
+normalClassDeclarationToExpr ncd =
+
+      let mods = Syntax.normalClassDeclarationModifiers ncd
+          id = Syntax.normalClassDeclarationIdentifier ncd
+          tparams = Syntax.normalClassDeclarationParameters ncd
+          msuperc = Syntax.normalClassDeclarationExtends ncd
+          superi = Syntax.normalClassDeclarationImplements ncd
+          body = Syntax.normalClassDeclarationBody ncd
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map classModifierToExpr mods))),
+        (Just (Serialization.cst "class")),
+        (Just (Serialization.noSep (Optionals.cat [
+          Just (typeIdentifierToExpr id),
+          (Logic.ifElse (Lists.null tparams) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map typeParameterToExpr tparams))))]))),
+        (Optionals.map (\c -> Serialization.spaceSep [
+          Serialization.cst "extends",
+          (classTypeToExpr c)]) msuperc),
+        (Logic.ifElse (Lists.null superi) Nothing (Just (Serialization.spaceSep [
+          Serialization.cst "implements",
+          (Serialization.commaSep Serialization.inlineStyle (Lists.map interfaceTypeToExpr superi))]))),
+        (Just (classBodyToExpr body))]))
+
+normalInterfaceDeclarationToExpr :: Syntax.NormalInterfaceDeclaration -> Ast.Expr
+normalInterfaceDeclarationToExpr nid =
+
+      let mods = Syntax.normalInterfaceDeclarationModifiers nid
+          id = Syntax.normalInterfaceDeclarationIdentifier nid
+          tparams = Syntax.normalInterfaceDeclarationParameters nid
+          extends = Syntax.normalInterfaceDeclarationExtends nid
+          body = Syntax.normalInterfaceDeclarationBody nid
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map interfaceModifierToExpr mods))),
+        (Just (Serialization.cst "interface")),
+        (Just (Serialization.noSep (Optionals.cat [
+          Just (typeIdentifierToExpr id),
+          (Logic.ifElse (Lists.null tparams) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map typeParameterToExpr tparams))))]))),
+        (Logic.ifElse (Lists.null extends) Nothing (Just (Serialization.spaceSep [
+          Serialization.cst "extends",
+          (Serialization.commaSep Serialization.inlineStyle (Lists.map interfaceTypeToExpr extends))]))),
+        (Just (interfaceBodyToExpr body))]))
+
+numericTypeToExpr :: Syntax.NumericType -> Ast.Expr
+numericTypeToExpr nt =
+    case nt of
+      Syntax.NumericTypeIntegral v0 -> integralTypeToExpr v0
+      Syntax.NumericTypeFloatingPoint v0 -> floatingPointTypeToExpr v0
+
+packageDeclarationToExpr :: Syntax.PackageDeclaration -> Ast.Expr
+packageDeclarationToExpr pd =
+
+      let mods = Syntax.packageDeclarationModifiers pd
+          ids = Syntax.packageDeclarationIdentifiers pd
+      in (Serialization.withSemi (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map packageModifierToExpr mods))),
+        (Just (Serialization.spaceSep [
+          Serialization.cst "package",
+          (Serialization.cst (Strings.intercalate "." (Lists.map (\id -> Syntax.unIdentifier id) ids)))]))])))
+
+packageModifierToExpr :: Syntax.PackageModifier -> Ast.Expr
+packageModifierToExpr pm = annotationToExpr (Syntax.unPackageModifier pm)
+
+packageNameToExpr :: Syntax.PackageName -> Ast.Expr
+packageNameToExpr pn = Serialization.dotSep (Lists.map identifierToExpr (Syntax.unPackageName pn))
+
+packageOrTypeNameToExpr :: Syntax.PackageOrTypeName -> Ast.Expr
+packageOrTypeNameToExpr potn = Serialization.dotSep (Lists.map identifierToExpr (Syntax.unPackageOrTypeName potn))
+
+postDecrementExpressionToExpr :: t0 -> Ast.Expr
+postDecrementExpressionToExpr _ = Serialization.cst "STUB:PostDecrementExpression"
+
+postIncrementExpressionToExpr :: t0 -> Ast.Expr
+postIncrementExpressionToExpr _ = Serialization.cst "STUB:PostIncrementExpression"
+
+postfixExpressionToExpr :: Syntax.PostfixExpression -> Ast.Expr
+postfixExpressionToExpr e =
+    case e of
+      Syntax.PostfixExpressionPrimary v0 -> primaryToExpr v0
+      Syntax.PostfixExpressionName v0 -> expressionNameToExpr v0
+      Syntax.PostfixExpressionPostIncrement v0 -> postIncrementExpressionToExpr v0
+      Syntax.PostfixExpressionPostDecrement v0 -> postDecrementExpressionToExpr v0
+
+preDecrementExpressionToExpr :: t0 -> Ast.Expr
+preDecrementExpressionToExpr _ = Serialization.cst "STUB:PreDecrementExpression"
+
+preIncrementExpressionToExpr :: t0 -> Ast.Expr
+preIncrementExpressionToExpr _ = Serialization.cst "STUB:PreIncrementExpression"
+
+primaryNoNewArrayExpressionExpressionToExpr :: Syntax.PrimaryNoNewArrayExpression -> Ast.Expr
+primaryNoNewArrayExpressionExpressionToExpr p =
+    case p of
+      Syntax.PrimaryNoNewArrayExpressionLiteral v0 -> literalToExpr v0
+      Syntax.PrimaryNoNewArrayExpressionClassLiteral v0 -> classLiteralToExpr v0
+      Syntax.PrimaryNoNewArrayExpressionThis -> Serialization.cst "this"
+      Syntax.PrimaryNoNewArrayExpressionDotThis v0 -> Serialization.dotSep [
+        typeNameToExpr v0,
+        (Serialization.cst "this")]
+      Syntax.PrimaryNoNewArrayExpressionParens v0 -> Serialization.parenList False [
+        expressionToExpr v0]
+      Syntax.PrimaryNoNewArrayExpressionClassInstance v0 -> classInstanceCreationExpressionToExpr v0
+      Syntax.PrimaryNoNewArrayExpressionFieldAccess v0 -> fieldAccessToExpr v0
+      Syntax.PrimaryNoNewArrayExpressionArrayAccess v0 -> arrayAccessToExpr v0
+      Syntax.PrimaryNoNewArrayExpressionMethodInvocation v0 -> methodInvocationToExpr v0
+      Syntax.PrimaryNoNewArrayExpressionMethodReference v0 -> methodReferenceToExpr v0
+
+primaryToExpr :: Syntax.Primary -> Ast.Expr
+primaryToExpr p =
+    case p of
+      Syntax.PrimaryNoNewArray v0 -> primaryNoNewArrayExpressionExpressionToExpr v0
+      Syntax.PrimaryArrayCreation v0 -> arrayCreationExpressionToExpr v0
+
+primitiveTypeToExpr :: Syntax.PrimitiveType -> Ast.Expr
+primitiveTypeToExpr pt =
+    case pt of
+      Syntax.PrimitiveTypeNumeric v0 -> numericTypeToExpr v0
+      Syntax.PrimitiveTypeBoolean -> Serialization.cst "boolean"
+
+primitiveTypeWithAnnotationsToExpr :: Syntax.PrimitiveTypeWithAnnotations -> Ast.Expr
+primitiveTypeWithAnnotationsToExpr ptwa =
+
+      let pt = Syntax.primitiveTypeWithAnnotationsType ptwa
+          anns = Syntax.primitiveTypeWithAnnotationsAnnotations ptwa
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null anns) Nothing (Just (Serialization.spaceSep (Lists.map annotationToExpr anns))),
+        (Just (primitiveTypeToExpr pt))]))
+
+receiverParameterToExpr :: t0 -> Ast.Expr
+receiverParameterToExpr _ = Serialization.cst "STUB:ReceiverParameter"
+
+referenceTypeToExpr :: Syntax.ReferenceType -> Ast.Expr
+referenceTypeToExpr rt =
+    case rt of
+      Syntax.ReferenceTypeClassOrInterface v0 -> classOrInterfaceTypeToExpr v0
+      Syntax.ReferenceTypeVariable v0 -> typeVariableToExpr v0
+      Syntax.ReferenceTypeArray v0 -> arrayTypeToExpr v0
+
+relationalExpressionGreaterThanEqualToExpr :: Syntax.RelationalExpression_GreaterThanEqual -> Ast.Expr
+relationalExpressionGreaterThanEqualToExpr gte =
+    Serialization.infixWs ">=" (relationalExpressionToExpr (Syntax.relationalExpression_GreaterThanEqualLhs gte)) (shiftExpressionToExpr (Syntax.relationalExpression_GreaterThanEqualRhs gte))
+
+relationalExpressionGreaterThanToExpr :: Syntax.RelationalExpression_GreaterThan -> Ast.Expr
+relationalExpressionGreaterThanToExpr gt =
+    Serialization.infixWs ">" (relationalExpressionToExpr (Syntax.relationalExpression_GreaterThanLhs gt)) (shiftExpressionToExpr (Syntax.relationalExpression_GreaterThanRhs gt))
+
+relationalExpressionInstanceOfToExpr :: Syntax.InstanceofExpression -> Ast.Expr
+relationalExpressionInstanceOfToExpr io =
+
+      let rhsExpr =
+              case (Syntax.instanceofExpressionRhs io) of
+                Syntax.InstanceofExpression_RhsReferenceType v0 -> referenceTypeToExpr v0
+                Syntax.InstanceofExpression_RhsPattern _ -> Serialization.cst "STUB:Pattern"
+      in (Serialization.infixWs "instanceof" (relationalExpressionToExpr (Syntax.instanceofExpressionLhs io)) rhsExpr)
+
+relationalExpressionLessThanEqualToExpr :: Syntax.RelationalExpression_LessThanEqual -> Ast.Expr
+relationalExpressionLessThanEqualToExpr lte =
+    Serialization.infixWs "<=" (relationalExpressionToExpr (Syntax.relationalExpression_LessThanEqualLhs lte)) (shiftExpressionToExpr (Syntax.relationalExpression_LessThanEqualRhs lte))
+
+relationalExpressionLessThanToExpr :: Syntax.RelationalExpression_LessThan -> Ast.Expr
+relationalExpressionLessThanToExpr lt =
+    Serialization.infixWs "<" (relationalExpressionToExpr (Syntax.relationalExpression_LessThanLhs lt)) (shiftExpressionToExpr (Syntax.relationalExpression_LessThanRhs lt))
+
+relationalExpressionToExpr :: Syntax.RelationalExpression -> Ast.Expr
+relationalExpressionToExpr e =
+    case e of
+      Syntax.RelationalExpressionSimple v0 -> shiftExpressionToExpr v0
+      Syntax.RelationalExpressionLessThan v0 -> relationalExpressionLessThanToExpr v0
+      Syntax.RelationalExpressionGreaterThan v0 -> relationalExpressionGreaterThanToExpr v0
+      Syntax.RelationalExpressionLessThanEqual v0 -> relationalExpressionLessThanEqualToExpr v0
+      Syntax.RelationalExpressionGreaterThanEqual v0 -> relationalExpressionGreaterThanEqualToExpr v0
+      Syntax.RelationalExpressionInstanceofExpression v0 -> relationalExpressionInstanceOfToExpr v0
+
+resultToExpr :: Syntax.Result -> Ast.Expr
+resultToExpr r =
+    case r of
+      Syntax.ResultType v0 -> unannTypeToExpr v0
+      Syntax.ResultVoid -> Serialization.cst "void"
+
+returnStatementToExpr :: Syntax.ReturnStatement -> Ast.Expr
+returnStatementToExpr rs =
+
+      let mex = Syntax.unReturnStatement rs
+      in (Serialization.withSemi (Serialization.spaceSep (Optionals.cat [
+        Just (Serialization.cst "return"),
+        (Optionals.map expressionToExpr mex)])))
+
+-- | Sanitize a string for use in a Java comment
+sanitizeJavaComment :: String -> String
+sanitizeJavaComment s =
+    Strings.intercalate "&gt;" (Strings.splitOn ">" (Strings.intercalate "&lt;" (Strings.splitOn "<" (Strings.intercalate "&amp;" (Strings.splitOn "&" s)))))
+
+shiftExpressionToExpr :: Syntax.ShiftExpression -> Ast.Expr
+shiftExpressionToExpr e =
+    case e of
+      Syntax.ShiftExpressionUnary v0 -> additiveExpressionToExpr v0
+      Syntax.ShiftExpressionShiftLeft v0 -> Serialization.infixWs "<<" (shiftExpressionToExpr (Syntax.shiftExpression_BinaryLhs v0)) (additiveExpressionToExpr (Syntax.shiftExpression_BinaryRhs v0))
+      Syntax.ShiftExpressionShiftRight v0 -> Serialization.infixWs ">>" (shiftExpressionToExpr (Syntax.shiftExpression_BinaryLhs v0)) (additiveExpressionToExpr (Syntax.shiftExpression_BinaryRhs v0))
+      Syntax.ShiftExpressionShiftRightZeroFill v0 -> Serialization.infixWs ">>>" (shiftExpressionToExpr (Syntax.shiftExpression_BinaryLhs v0)) (additiveExpressionToExpr (Syntax.shiftExpression_BinaryRhs v0))
+
+simpleTypeNameToExpr :: Syntax.SimpleTypeName -> Ast.Expr
+simpleTypeNameToExpr stn = typeIdentifierToExpr (Syntax.unSimpleTypeName stn)
+
+singleElementAnnotationToExpr :: Syntax.SingleElementAnnotation -> Ast.Expr
+singleElementAnnotationToExpr sea =
+
+      let tname = Syntax.singleElementAnnotationName sea
+          mv = Syntax.singleElementAnnotationValue sea
+      in (Optionals.cases mv (markerAnnotationToExpr (Syntax.MarkerAnnotation tname)) (\v -> Serialization.prefix "@" (Serialization.noSep [
+        typeNameToExpr tname,
+        (Serialization.parenList False [
+          elementValueToExpr v])])))
+
+-- | Create a single-line Java comment. Empty text emits `//` (no trailing space) so blank line comments don't carry trailing whitespace.
+singleLineComment :: String -> Ast.Expr
+singleLineComment c =
+
+      let sanitized = sanitizeJavaComment c
+      in (Serialization.cst (Logic.ifElse (Equality.equal sanitized "") "//" (Strings.cat2 "// " sanitized)))
+
+statementExpressionToExpr :: Syntax.StatementExpression -> Ast.Expr
+statementExpressionToExpr e =
+    case e of
+      Syntax.StatementExpressionAssignment v0 -> assignmentToExpr v0
+      Syntax.StatementExpressionPreIncrement v0 -> preIncrementExpressionToExpr v0
+      Syntax.StatementExpressionPreDecrement v0 -> preDecrementExpressionToExpr v0
+      Syntax.StatementExpressionPostIncrement v0 -> postIncrementExpressionToExpr v0
+      Syntax.StatementExpressionPostDecrement v0 -> postDecrementExpressionToExpr v0
+      Syntax.StatementExpressionMethodInvocation v0 -> methodInvocationToExpr v0
+      Syntax.StatementExpressionClassInstanceCreation v0 -> classInstanceCreationExpressionToExpr v0
+
+statementToExpr :: Syntax.Statement -> Ast.Expr
+statementToExpr s =
+    case s of
+      Syntax.StatementWithoutTrailing v0 -> statementWithoutTrailingSubstatementToExpr v0
+      Syntax.StatementLabeled v0 -> labeledStatementToExpr v0
+      Syntax.StatementIfThen v0 -> ifThenStatementToExpr v0
+      Syntax.StatementIfThenElse v0 -> ifThenElseStatementToExpr v0
+      Syntax.StatementWhile v0 -> whileStatementToExpr v0
+      Syntax.StatementFor v0 -> forStatementToExpr v0
+
+statementWithoutTrailingSubstatementToExpr :: Syntax.StatementWithoutTrailingSubstatement -> Ast.Expr
+statementWithoutTrailingSubstatementToExpr s =
+    case s of
+      Syntax.StatementWithoutTrailingSubstatementBlock v0 -> blockToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementEmpty -> Serialization.cst ";"
+      Syntax.StatementWithoutTrailingSubstatementExpression v0 -> expressionStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementAssert v0 -> assertStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementSwitch v0 -> switchStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementDo v0 -> doStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementBreak v0 -> breakStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementContinue v0 -> continueStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementReturn v0 -> returnStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementSynchronized v0 -> synchronizedStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementThrow v0 -> throwStatementToExpr v0
+      Syntax.StatementWithoutTrailingSubstatementTry v0 -> tryStatementToExpr v0
+
+staticInitializerToExpr :: t0 -> Ast.Expr
+staticInitializerToExpr _ = Serialization.cst "STUB:StaticInitializer"
+
+-- | Serialize a Java string literal with proper Unicode escaping.
+stringLiteralToExpr :: Syntax.StringLiteral -> Ast.Expr
+stringLiteralToExpr sl =
+
+      let s = Syntax.unStringLiteral sl
+      in (Serialization.cst (Strings.cat2 "\"" (Strings.cat2 (Serde.escapeJavaString s) "\"")))
+
+switchStatementToExpr :: t0 -> Ast.Expr
+switchStatementToExpr _ = Serialization.cst "STUB:SwitchStatement"
+
+synchronizedStatementToExpr :: t0 -> Ast.Expr
+synchronizedStatementToExpr _ = Serialization.cst "STUB:SynchronizedStatement"
+
+throwStatementToExpr :: Syntax.ThrowStatement -> Ast.Expr
+throwStatementToExpr ts =
+    Serialization.withSemi (Serialization.spaceSep [
+      Serialization.cst "throw",
+      (expressionToExpr (Syntax.unThrowStatement ts))])
+
+throwsToExpr :: t0 -> Ast.Expr
+throwsToExpr _ = Serialization.cst "STUB:Throws"
+
+tryStatementToExpr :: t0 -> Ast.Expr
+tryStatementToExpr _ = Serialization.cst "STUB:TryStatement"
+
+typeArgumentToExpr :: Syntax.TypeArgument -> Ast.Expr
+typeArgumentToExpr a =
+    case a of
+      Syntax.TypeArgumentReference v0 -> referenceTypeToExpr v0
+      Syntax.TypeArgumentWildcard v0 -> wildcardToExpr v0
+
+typeArgumentsOrDiamondToExpr :: Syntax.TypeArgumentsOrDiamond -> Ast.Expr
+typeArgumentsOrDiamondToExpr targs =
+    case targs of
+      Syntax.TypeArgumentsOrDiamondArguments v0 -> Serialization.angleBracesList Serialization.inlineStyle (Lists.map typeArgumentToExpr v0)
+      Syntax.TypeArgumentsOrDiamondDiamond -> Serialization.cst "<>"
+
+typeBoundToExpr :: Syntax.TypeBound -> Ast.Expr
+typeBoundToExpr b =
+    case b of
+      Syntax.TypeBoundVariable v0 -> typeVariableToExpr v0
+      Syntax.TypeBoundClassOrInterface v0 ->
+        let cit = Syntax.typeBound_ClassOrInterfaceType v0
+            additional = Syntax.typeBound_ClassOrInterfaceAdditional v0
+        in (Logic.ifElse (Lists.null additional) (classOrInterfaceTypeToExpr cit) (Serialization.spaceSep (Lists.cons (classOrInterfaceTypeToExpr cit) (Lists.map additionalBoundToExpr additional))))
+
+typeDeclarationToExpr :: Syntax.TopLevelClassOrInterfaceDeclaration -> Ast.Expr
+typeDeclarationToExpr d =
+    case d of
+      Syntax.TopLevelClassOrInterfaceDeclarationClass v0 -> classDeclarationToExpr v0
+      Syntax.TopLevelClassOrInterfaceDeclarationInterface v0 -> interfaceDeclarationToExpr v0
+      Syntax.TopLevelClassOrInterfaceDeclarationNone -> Serialization.cst ";"
+
+typeDeclarationWithCommentsToExpr :: Syntax.TopLevelClassOrInterfaceDeclarationWithComments -> Ast.Expr
+typeDeclarationWithCommentsToExpr tdwc =
+
+      let d = Syntax.topLevelClassOrInterfaceDeclarationWithCommentsValue tdwc
+          mc = Syntax.topLevelClassOrInterfaceDeclarationWithCommentsComments tdwc
+      in (withComments mc (typeDeclarationToExpr d))
+
+typeIdentifierToExpr :: Syntax.TypeIdentifier -> Ast.Expr
+typeIdentifierToExpr tid = identifierToExpr (Syntax.unTypeIdentifier tid)
+
+typeNameToExpr :: Syntax.TypeName -> Ast.Expr
+typeNameToExpr tn =
+
+      let id = Syntax.typeNameIdentifier tn
+          mqual = Syntax.typeNameQualifier tn
+      in (Serialization.dotSep (Optionals.cat [
+        Optionals.map packageOrTypeNameToExpr mqual,
+        (Just (typeIdentifierToExpr id))]))
+
+typeParameterModifierToExpr :: Syntax.TypeParameterModifier -> Ast.Expr
+typeParameterModifierToExpr tpm = annotationToExpr (Syntax.unTypeParameterModifier tpm)
+
+typeParameterToExpr :: Syntax.TypeParameter -> Ast.Expr
+typeParameterToExpr tp =
+
+      let mods = Syntax.typeParameterModifiers tp
+          id = Syntax.typeParameterIdentifier tp
+          bound = Syntax.typeParameterBound tp
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null mods) Nothing (Just (Serialization.spaceSep (Lists.map typeParameterModifierToExpr mods))),
+        (Just (typeIdentifierToExpr id)),
+        (Optionals.map (\b -> Serialization.spaceSep [
+          Serialization.cst "extends",
+          (typeBoundToExpr b)]) bound)]))
+
+typeToExpr :: Syntax.Type -> Ast.Expr
+typeToExpr t =
+    case t of
+      Syntax.TypePrimitive v0 -> primitiveTypeWithAnnotationsToExpr v0
+      Syntax.TypeReference v0 -> referenceTypeToExpr v0
+
+typeVariableToExpr :: Syntax.TypeVariable -> Ast.Expr
+typeVariableToExpr tv =
+
+      let anns = Syntax.typeVariableAnnotations tv
+          id = Syntax.typeVariableIdentifier tv
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null anns) Nothing (Just (Serialization.spaceSep (Lists.map annotationToExpr anns))),
+        (Just (typeIdentifierToExpr id))]))
+
+unannTypeToExpr :: Syntax.UnannType -> Ast.Expr
+unannTypeToExpr ut = typeToExpr (Syntax.unUnannType ut)
+
+unaryExpressionNotPlusMinusToExpr :: Syntax.UnaryExpressionNotPlusMinus -> Ast.Expr
+unaryExpressionNotPlusMinusToExpr e =
+    case e of
+      Syntax.UnaryExpressionNotPlusMinusPostfix v0 -> postfixExpressionToExpr v0
+      Syntax.UnaryExpressionNotPlusMinusTilde v0 -> Serialization.spaceSep [
+        Serialization.cst "~",
+        (unaryExpressionToExpr v0)]
+      Syntax.UnaryExpressionNotPlusMinusNot v0 -> Serialization.noSep [
+        Serialization.cst "!",
+        (unaryExpressionToExpr v0)]
+      Syntax.UnaryExpressionNotPlusMinusCast v0 -> castExpressionToExpr v0
+
+unaryExpressionToExpr :: Syntax.UnaryExpression -> Ast.Expr
+unaryExpressionToExpr e =
+    case e of
+      Syntax.UnaryExpressionPreIncrement v0 -> preIncrementExpressionToExpr v0
+      Syntax.UnaryExpressionPreDecrement v0 -> preDecrementExpressionToExpr v0
+      Syntax.UnaryExpressionPlus v0 -> Serialization.spaceSep [
+        Serialization.cst "+",
+        (unaryExpressionToExpr v0)]
+      Syntax.UnaryExpressionMinus v0 -> Serialization.spaceSep [
+        Serialization.cst "-",
+        (unaryExpressionToExpr v0)]
+      Syntax.UnaryExpressionOther v0 -> unaryExpressionNotPlusMinusToExpr v0
+
+unqualifiedClassInstanceCreationExpressionToExpr :: Syntax.UnqualifiedClassInstanceCreationExpression -> Ast.Expr
+unqualifiedClassInstanceCreationExpressionToExpr ucice =
+
+      let targs = Syntax.unqualifiedClassInstanceCreationExpressionTypeArguments ucice
+          cit = Syntax.unqualifiedClassInstanceCreationExpressionClassOrInterface ucice
+          args = Syntax.unqualifiedClassInstanceCreationExpressionArguments ucice
+          mbody = Syntax.unqualifiedClassInstanceCreationExpressionBody ucice
+      in (Serialization.spaceSep (Optionals.cat [
+        Just (Serialization.cst "new"),
+        (Logic.ifElse (Lists.null targs) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map typeArgumentToExpr targs)))),
+        (Just (Serialization.noSep [
+          classOrInterfaceTypeToInstantiateToExpr cit,
+          (Serialization.parenList False (Lists.map expressionToExpr args))])),
+        (Optionals.map classBodyToExpr mbody)]))
+
+variableArityParameterToExpr :: t0 -> Ast.Expr
+variableArityParameterToExpr _ = Serialization.cst "STUB:VariableArityParameter"
+
+variableDeclaratorIdToExpr :: Syntax.VariableDeclaratorId -> Ast.Expr
+variableDeclaratorIdToExpr vdi =
+
+      let id = Syntax.variableDeclaratorIdIdentifier vdi
+          mdims = Syntax.variableDeclaratorIdDims vdi
+      in (Serialization.noSep (Optionals.cat [
+        Just (identifierToExpr id),
+        (Optionals.map dimsToExpr mdims)]))
+
+variableDeclaratorToExpr :: Syntax.VariableDeclarator -> Ast.Expr
+variableDeclaratorToExpr vd =
+
+      let id = Syntax.variableDeclaratorId vd
+          minit = Syntax.variableDeclaratorInitializer vd
+          idSec = variableDeclaratorIdToExpr id
+      in (Optionals.cases minit idSec (\init -> Serialization.infixWs "=" idSec (variableInitializerToExpr init)))
+
+variableInitializerToExpr :: Syntax.VariableInitializer -> Ast.Expr
+variableInitializerToExpr i =
+    case i of
+      Syntax.VariableInitializerExpression v0 -> expressionToExpr v0
+      Syntax.VariableInitializerArrayInitializer v0 -> arrayInitializerToExpr v0
+
+variableModifierToExpr :: Syntax.VariableModifier -> Ast.Expr
+variableModifierToExpr m =
+    case m of
+      Syntax.VariableModifierAnnotation v0 -> annotationToExpr v0
+      Syntax.VariableModifierFinal -> Serialization.cst "final"
+
+whileStatementToExpr :: Syntax.WhileStatement -> Ast.Expr
+whileStatementToExpr ws =
+
+      let mcond = Syntax.whileStatementCond ws
+          body = Syntax.whileStatementBody ws
+          condSer = Optionals.cases mcond (Serialization.cst "true") (\c -> expressionToExpr c)
+      in (Serialization.spaceSep [
+        Serialization.cst "while",
+        (Serialization.parenList False [
+          condSer]),
+        (Serialization.curlyBlock Serialization.fullBlockStyle (statementToExpr body))])
+
+wildcardBoundsToExpr :: Syntax.WildcardBounds -> Ast.Expr
+wildcardBoundsToExpr b =
+    case b of
+      Syntax.WildcardBoundsExtends v0 -> Serialization.spaceSep [
+        Serialization.cst "extends",
+        (referenceTypeToExpr v0)]
+      Syntax.WildcardBoundsSuper v0 -> Serialization.spaceSep [
+        Serialization.cst "super",
+        (referenceTypeToExpr v0)]
+
+wildcardToExpr :: Syntax.Wildcard -> Ast.Expr
+wildcardToExpr w =
+
+      let anns = Syntax.wildcardAnnotations w
+          mbounds = Syntax.wildcardWildcard w
+      in (Serialization.spaceSep (Optionals.cat [
+        Logic.ifElse (Lists.null anns) Nothing (Just (Serialization.commaSep Serialization.inlineStyle (Lists.map annotationToExpr anns))),
+        (Just (Serialization.cst "*")),
+        (Optionals.map wildcardBoundsToExpr mbounds)]))
+
+-- | Wrap an expression with optional Javadoc comments. Blank lines inside the doc body emit ` *` (no trailing space) instead of ` * `.
+withComments :: Maybe String -> Ast.Expr -> Ast.Expr
+withComments mc expr =
+    Optionals.cases mc expr (\c -> Serialization.newlineSep [
+      Serialization.cst (Strings.cat2 "/**\n" (Strings.cat2 (Strings.intercalate "\n" (Lists.map (\l -> Logic.ifElse (Equality.equal l "") " *" (Strings.cat2 " * " l)) (Strings.lines (sanitizeJavaComment (Docs.renderDocStringWith javaDocEntityRef c))))) "\n */")),
+      expr])
diff --git a/src/main/haskell/Hydra/Java/Syntax.hs b/src/main/haskell/Hydra/Java/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Java/Syntax.hs
@@ -0,0 +1,3579 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | A Java syntax module. Tracks the Oracle Java SE 21 BNF:
+-- |   https://docs.oracle.com/javase/specs/jls/se21/html/jls-19.html
+-- | Note: all *WithComments types were added manually, rather than derived from the BNF, which does not allow for comments.
+
+module Hydra.Java.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
+
+newtype Identifier =
+  Identifier {
+    unIdentifier :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_Identifier = Core.Name "hydra.java.syntax.Identifier"
+
+newtype TypeIdentifier =
+  TypeIdentifier {
+    unTypeIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeIdentifier = Core.Name "hydra.java.syntax.TypeIdentifier"
+
+data Literal =
+  LiteralNull |
+  LiteralInteger IntegerLiteral |
+  LiteralFloatingPoint FloatingPointLiteral |
+  LiteralBoolean Bool |
+  LiteralCharacter Int |
+  LiteralString StringLiteral |
+  LiteralTextBlock TextBlock
+  deriving (Eq, Ord, Read, Show)
+
+_Literal = Core.Name "hydra.java.syntax.Literal"
+
+_Literal_null = Core.Name "null"
+
+_Literal_integer = Core.Name "integer"
+
+_Literal_floatingPoint = Core.Name "floatingPoint"
+
+_Literal_boolean = Core.Name "boolean"
+
+_Literal_character = Core.Name "character"
+
+_Literal_string = Core.Name "string"
+
+_Literal_textBlock = Core.Name "textBlock"
+
+-- | Note: this is an approximation which ignores encoding
+newtype IntegerLiteral =
+  IntegerLiteral {
+    unIntegerLiteral :: Integer}
+  deriving (Eq, Ord, Read, Show)
+
+_IntegerLiteral = Core.Name "hydra.java.syntax.IntegerLiteral"
+
+-- | Note: this is an approximation which ignores encoding
+newtype FloatingPointLiteral =
+  FloatingPointLiteral {
+    unFloatingPointLiteral :: Double}
+  deriving (Eq, Ord, Read, Show)
+
+_FloatingPointLiteral = Core.Name "hydra.java.syntax.FloatingPointLiteral"
+
+-- | Note: this is an approximation which ignores encoding
+newtype StringLiteral =
+  StringLiteral {
+    unStringLiteral :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_StringLiteral = Core.Name "hydra.java.syntax.StringLiteral"
+
+-- | Note: this is an approximation which ignores encoding and incidental whitespace stripping
+newtype TextBlock =
+  TextBlock {
+    unTextBlock :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_TextBlock = Core.Name "hydra.java.syntax.TextBlock"
+
+data Type =
+  TypePrimitive PrimitiveTypeWithAnnotations |
+  TypeReference ReferenceType
+  deriving (Eq, Ord, Read, Show)
+
+_Type = Core.Name "hydra.java.syntax.Type"
+
+_Type_primitive = Core.Name "primitive"
+
+_Type_reference = Core.Name "reference"
+
+data PrimitiveTypeWithAnnotations =
+  PrimitiveTypeWithAnnotations {
+    primitiveTypeWithAnnotationsType :: PrimitiveType,
+    primitiveTypeWithAnnotationsAnnotations :: [Annotation]}
+  deriving (Eq, Ord, Read, Show)
+
+_PrimitiveTypeWithAnnotations = Core.Name "hydra.java.syntax.PrimitiveTypeWithAnnotations"
+
+_PrimitiveTypeWithAnnotations_type = Core.Name "type"
+
+_PrimitiveTypeWithAnnotations_annotations = Core.Name "annotations"
+
+data PrimitiveType =
+  PrimitiveTypeNumeric NumericType |
+  PrimitiveTypeBoolean
+  deriving (Eq, Ord, Read, Show)
+
+_PrimitiveType = Core.Name "hydra.java.syntax.PrimitiveType"
+
+_PrimitiveType_numeric = Core.Name "numeric"
+
+_PrimitiveType_boolean = Core.Name "boolean"
+
+data NumericType =
+  NumericTypeIntegral IntegralType |
+  NumericTypeFloatingPoint FloatingPointType
+  deriving (Eq, Ord, Read, Show)
+
+_NumericType = Core.Name "hydra.java.syntax.NumericType"
+
+_NumericType_integral = Core.Name "integral"
+
+_NumericType_floatingPoint = Core.Name "floatingPoint"
+
+data IntegralType =
+  IntegralTypeByte |
+  IntegralTypeShort |
+  IntegralTypeInt |
+  IntegralTypeLong |
+  IntegralTypeChar
+  deriving (Eq, Ord, Read, Show)
+
+_IntegralType = Core.Name "hydra.java.syntax.IntegralType"
+
+_IntegralType_byte = Core.Name "byte"
+
+_IntegralType_short = Core.Name "short"
+
+_IntegralType_int = Core.Name "int"
+
+_IntegralType_long = Core.Name "long"
+
+_IntegralType_char = Core.Name "char"
+
+data FloatingPointType =
+  FloatingPointTypeFloat |
+  FloatingPointTypeDouble
+  deriving (Eq, Ord, Read, Show)
+
+_FloatingPointType = Core.Name "hydra.java.syntax.FloatingPointType"
+
+_FloatingPointType_float = Core.Name "float"
+
+_FloatingPointType_double = Core.Name "double"
+
+data ReferenceType =
+  ReferenceTypeClassOrInterface ClassOrInterfaceType |
+  ReferenceTypeVariable TypeVariable |
+  ReferenceTypeArray ArrayType
+  deriving (Eq, Ord, Read, Show)
+
+_ReferenceType = Core.Name "hydra.java.syntax.ReferenceType"
+
+_ReferenceType_classOrInterface = Core.Name "classOrInterface"
+
+_ReferenceType_variable = Core.Name "variable"
+
+_ReferenceType_array = Core.Name "array"
+
+data ClassOrInterfaceType =
+  ClassOrInterfaceTypeClass ClassType |
+  ClassOrInterfaceTypeInterface InterfaceType
+  deriving (Eq, Ord, Read, Show)
+
+_ClassOrInterfaceType = Core.Name "hydra.java.syntax.ClassOrInterfaceType"
+
+_ClassOrInterfaceType_class = Core.Name "class"
+
+_ClassOrInterfaceType_interface = Core.Name "interface"
+
+data ClassType =
+  ClassType {
+    classTypeAnnotations :: [Annotation],
+    classTypeQualifier :: ClassTypeQualifier,
+    classTypeIdentifier :: TypeIdentifier,
+    classTypeArguments :: [TypeArgument]}
+  deriving (Eq, Ord, Read, Show)
+
+_ClassType = Core.Name "hydra.java.syntax.ClassType"
+
+_ClassType_annotations = Core.Name "annotations"
+
+_ClassType_qualifier = Core.Name "qualifier"
+
+_ClassType_identifier = Core.Name "identifier"
+
+_ClassType_arguments = Core.Name "arguments"
+
+data ClassTypeQualifier =
+  ClassTypeQualifierNone |
+  ClassTypeQualifierPackage PackageName |
+  ClassTypeQualifierParent ClassOrInterfaceType
+  deriving (Eq, Ord, Read, Show)
+
+_ClassTypeQualifier = Core.Name "hydra.java.syntax.ClassTypeQualifier"
+
+_ClassTypeQualifier_none = Core.Name "none"
+
+_ClassTypeQualifier_package = Core.Name "package"
+
+_ClassTypeQualifier_parent = Core.Name "parent"
+
+newtype InterfaceType =
+  InterfaceType {
+    unInterfaceType :: ClassType}
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceType = Core.Name "hydra.java.syntax.InterfaceType"
+
+data TypeVariable =
+  TypeVariable {
+    typeVariableAnnotations :: [Annotation],
+    typeVariableIdentifier :: TypeIdentifier}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeVariable = Core.Name "hydra.java.syntax.TypeVariable"
+
+_TypeVariable_annotations = Core.Name "annotations"
+
+_TypeVariable_identifier = Core.Name "identifier"
+
+data ArrayType =
+  ArrayType {
+    arrayTypeDims :: Dims,
+    arrayTypeVariant :: ArrayType_Variant}
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayType = Core.Name "hydra.java.syntax.ArrayType"
+
+_ArrayType_dims = Core.Name "dims"
+
+_ArrayType_variant = Core.Name "variant"
+
+data ArrayType_Variant =
+  ArrayType_VariantPrimitive PrimitiveTypeWithAnnotations |
+  ArrayType_VariantClassOrInterface ClassOrInterfaceType |
+  ArrayType_VariantVariable TypeVariable
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayType_Variant = Core.Name "hydra.java.syntax.ArrayType_Variant"
+
+_ArrayType_Variant_primitive = Core.Name "primitive"
+
+_ArrayType_Variant_classOrInterface = Core.Name "classOrInterface"
+
+_ArrayType_Variant_variable = Core.Name "variable"
+
+newtype Dims =
+  Dims {
+    unDims :: [[Annotation]]}
+  deriving (Eq, Ord, Read, Show)
+
+_Dims = Core.Name "hydra.java.syntax.Dims"
+
+data TypeParameter =
+  TypeParameter {
+    typeParameterModifiers :: [TypeParameterModifier],
+    typeParameterIdentifier :: TypeIdentifier,
+    typeParameterBound :: (Maybe TypeBound)}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeParameter = Core.Name "hydra.java.syntax.TypeParameter"
+
+_TypeParameter_modifiers = Core.Name "modifiers"
+
+_TypeParameter_identifier = Core.Name "identifier"
+
+_TypeParameter_bound = Core.Name "bound"
+
+newtype TypeParameterModifier =
+  TypeParameterModifier {
+    unTypeParameterModifier :: Annotation}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeParameterModifier = Core.Name "hydra.java.syntax.TypeParameterModifier"
+
+data TypeBound =
+  TypeBoundVariable TypeVariable |
+  TypeBoundClassOrInterface TypeBound_ClassOrInterface
+  deriving (Eq, Ord, Read, Show)
+
+_TypeBound = Core.Name "hydra.java.syntax.TypeBound"
+
+_TypeBound_variable = Core.Name "variable"
+
+_TypeBound_classOrInterface = Core.Name "classOrInterface"
+
+data TypeBound_ClassOrInterface =
+  TypeBound_ClassOrInterface {
+    typeBound_ClassOrInterfaceType :: ClassOrInterfaceType,
+    typeBound_ClassOrInterfaceAdditional :: [AdditionalBound]}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeBound_ClassOrInterface = Core.Name "hydra.java.syntax.TypeBound_ClassOrInterface"
+
+_TypeBound_ClassOrInterface_type = Core.Name "type"
+
+_TypeBound_ClassOrInterface_additional = Core.Name "additional"
+
+newtype AdditionalBound =
+  AdditionalBound {
+    unAdditionalBound :: InterfaceType}
+  deriving (Eq, Ord, Read, Show)
+
+_AdditionalBound = Core.Name "hydra.java.syntax.AdditionalBound"
+
+data TypeArgument =
+  TypeArgumentReference ReferenceType |
+  TypeArgumentWildcard Wildcard
+  deriving (Eq, Ord, Read, Show)
+
+_TypeArgument = Core.Name "hydra.java.syntax.TypeArgument"
+
+_TypeArgument_reference = Core.Name "reference"
+
+_TypeArgument_wildcard = Core.Name "wildcard"
+
+data Wildcard =
+  Wildcard {
+    wildcardAnnotations :: [Annotation],
+    wildcardWildcard :: (Maybe WildcardBounds)}
+  deriving (Eq, Ord, Read, Show)
+
+_Wildcard = Core.Name "hydra.java.syntax.Wildcard"
+
+_Wildcard_annotations = Core.Name "annotations"
+
+_Wildcard_wildcard = Core.Name "wildcard"
+
+data WildcardBounds =
+  WildcardBoundsExtends ReferenceType |
+  WildcardBoundsSuper ReferenceType
+  deriving (Eq, Ord, Read, Show)
+
+_WildcardBounds = Core.Name "hydra.java.syntax.WildcardBounds"
+
+_WildcardBounds_extends = Core.Name "extends"
+
+_WildcardBounds_super = Core.Name "super"
+
+data ModuleName =
+  ModuleName {
+    moduleNameIdentifier :: Identifier,
+    moduleNameName :: (Maybe ModuleName)}
+  deriving (Eq, Ord, Read, Show)
+
+_ModuleName = Core.Name "hydra.java.syntax.ModuleName"
+
+_ModuleName_identifier = Core.Name "identifier"
+
+_ModuleName_name = Core.Name "name"
+
+newtype PackageName =
+  PackageName {
+    unPackageName :: [Identifier]}
+  deriving (Eq, Ord, Read, Show)
+
+_PackageName = Core.Name "hydra.java.syntax.PackageName"
+
+data TypeName =
+  TypeName {
+    typeNameIdentifier :: TypeIdentifier,
+    typeNameQualifier :: (Maybe PackageOrTypeName)}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeName = Core.Name "hydra.java.syntax.TypeName"
+
+_TypeName_identifier = Core.Name "identifier"
+
+_TypeName_qualifier = Core.Name "qualifier"
+
+data ExpressionName =
+  ExpressionName {
+    expressionNameQualifier :: (Maybe AmbiguousName),
+    expressionNameIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_ExpressionName = Core.Name "hydra.java.syntax.ExpressionName"
+
+_ExpressionName_qualifier = Core.Name "qualifier"
+
+_ExpressionName_identifier = Core.Name "identifier"
+
+newtype MethodName =
+  MethodName {
+    unMethodName :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodName = Core.Name "hydra.java.syntax.MethodName"
+
+newtype PackageOrTypeName =
+  PackageOrTypeName {
+    unPackageOrTypeName :: [Identifier]}
+  deriving (Eq, Ord, Read, Show)
+
+_PackageOrTypeName = Core.Name "hydra.java.syntax.PackageOrTypeName"
+
+newtype AmbiguousName =
+  AmbiguousName {
+    unAmbiguousName :: [Identifier]}
+  deriving (Eq, Ord, Read, Show)
+
+_AmbiguousName = Core.Name "hydra.java.syntax.AmbiguousName"
+
+data CompilationUnit =
+  CompilationUnitOrdinary OrdinaryCompilationUnit |
+  CompilationUnitModular ModularCompilationUnit
+  deriving (Eq, Ord, Read, Show)
+
+_CompilationUnit = Core.Name "hydra.java.syntax.CompilationUnit"
+
+_CompilationUnit_ordinary = Core.Name "ordinary"
+
+_CompilationUnit_modular = Core.Name "modular"
+
+data OrdinaryCompilationUnit =
+  OrdinaryCompilationUnit {
+    ordinaryCompilationUnitPackage :: (Maybe PackageDeclaration),
+    ordinaryCompilationUnitImports :: [ImportDeclaration],
+    ordinaryCompilationUnitTypes :: [TopLevelClassOrInterfaceDeclarationWithComments]}
+  deriving (Eq, Ord, Read, Show)
+
+_OrdinaryCompilationUnit = Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"
+
+_OrdinaryCompilationUnit_package = Core.Name "package"
+
+_OrdinaryCompilationUnit_imports = Core.Name "imports"
+
+_OrdinaryCompilationUnit_types = Core.Name "types"
+
+data ModularCompilationUnit =
+  ModularCompilationUnit {
+    modularCompilationUnitImports :: [ImportDeclaration],
+    modularCompilationUnitModule :: ModuleDeclaration}
+  deriving (Eq, Ord, Read, Show)
+
+_ModularCompilationUnit = Core.Name "hydra.java.syntax.ModularCompilationUnit"
+
+_ModularCompilationUnit_imports = Core.Name "imports"
+
+_ModularCompilationUnit_module = Core.Name "module"
+
+data PackageDeclaration =
+  PackageDeclaration {
+    packageDeclarationModifiers :: [PackageModifier],
+    packageDeclarationIdentifiers :: [Identifier]}
+  deriving (Eq, Ord, Read, Show)
+
+_PackageDeclaration = Core.Name "hydra.java.syntax.PackageDeclaration"
+
+_PackageDeclaration_modifiers = Core.Name "modifiers"
+
+_PackageDeclaration_identifiers = Core.Name "identifiers"
+
+newtype PackageModifier =
+  PackageModifier {
+    unPackageModifier :: Annotation}
+  deriving (Eq, Ord, Read, Show)
+
+_PackageModifier = Core.Name "hydra.java.syntax.PackageModifier"
+
+data ImportDeclaration =
+  ImportDeclarationSingleType SingleTypeImportDeclaration |
+  ImportDeclarationTypeImportOnDemand TypeImportOnDemandDeclaration |
+  ImportDeclarationSingleStaticImport SingleStaticImportDeclaration |
+  ImportDeclarationStaticImportOnDemand StaticImportOnDemandDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_ImportDeclaration = Core.Name "hydra.java.syntax.ImportDeclaration"
+
+_ImportDeclaration_singleType = Core.Name "singleType"
+
+_ImportDeclaration_typeImportOnDemand = Core.Name "typeImportOnDemand"
+
+_ImportDeclaration_singleStaticImport = Core.Name "singleStaticImport"
+
+_ImportDeclaration_staticImportOnDemand = Core.Name "staticImportOnDemand"
+
+newtype SingleTypeImportDeclaration =
+  SingleTypeImportDeclaration {
+    unSingleTypeImportDeclaration :: TypeName}
+  deriving (Eq, Ord, Read, Show)
+
+_SingleTypeImportDeclaration = Core.Name "hydra.java.syntax.SingleTypeImportDeclaration"
+
+newtype TypeImportOnDemandDeclaration =
+  TypeImportOnDemandDeclaration {
+    unTypeImportOnDemandDeclaration :: PackageOrTypeName}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeImportOnDemandDeclaration = Core.Name "hydra.java.syntax.TypeImportOnDemandDeclaration"
+
+data SingleStaticImportDeclaration =
+  SingleStaticImportDeclaration {
+    singleStaticImportDeclarationTypeName :: TypeName,
+    singleStaticImportDeclarationIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_SingleStaticImportDeclaration = Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"
+
+_SingleStaticImportDeclaration_typeName = Core.Name "typeName"
+
+_SingleStaticImportDeclaration_identifier = Core.Name "identifier"
+
+newtype StaticImportOnDemandDeclaration =
+  StaticImportOnDemandDeclaration {
+    unStaticImportOnDemandDeclaration :: TypeName}
+  deriving (Eq, Ord, Read, Show)
+
+_StaticImportOnDemandDeclaration = Core.Name "hydra.java.syntax.StaticImportOnDemandDeclaration"
+
+data TopLevelClassOrInterfaceDeclaration =
+  TopLevelClassOrInterfaceDeclarationClass ClassDeclaration |
+  TopLevelClassOrInterfaceDeclarationInterface InterfaceDeclaration |
+  TopLevelClassOrInterfaceDeclarationNone
+  deriving (Eq, Ord, Read, Show)
+
+_TopLevelClassOrInterfaceDeclaration = Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclaration"
+
+_TopLevelClassOrInterfaceDeclaration_class = Core.Name "class"
+
+_TopLevelClassOrInterfaceDeclaration_interface = Core.Name "interface"
+
+_TopLevelClassOrInterfaceDeclaration_none = Core.Name "none"
+
+data TopLevelClassOrInterfaceDeclarationWithComments =
+  TopLevelClassOrInterfaceDeclarationWithComments {
+    topLevelClassOrInterfaceDeclarationWithCommentsValue :: TopLevelClassOrInterfaceDeclaration,
+    topLevelClassOrInterfaceDeclarationWithCommentsComments :: (Maybe String)}
+  deriving (Eq, Ord, Read, Show)
+
+_TopLevelClassOrInterfaceDeclarationWithComments =
+    Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"
+
+_TopLevelClassOrInterfaceDeclarationWithComments_value = Core.Name "value"
+
+_TopLevelClassOrInterfaceDeclarationWithComments_comments = Core.Name "comments"
+
+data ModuleDeclaration =
+  ModuleDeclaration {
+    moduleDeclarationAnnotations :: [Annotation],
+    moduleDeclarationOpen :: Bool,
+    moduleDeclarationIdentifiers :: [Identifier],
+    moduleDeclarationDirectives :: [ModuleDirective]}
+  deriving (Eq, Ord, Read, Show)
+
+_ModuleDeclaration = Core.Name "hydra.java.syntax.ModuleDeclaration"
+
+_ModuleDeclaration_annotations = Core.Name "annotations"
+
+_ModuleDeclaration_open = Core.Name "open"
+
+_ModuleDeclaration_identifiers = Core.Name "identifiers"
+
+_ModuleDeclaration_directives = Core.Name "directives"
+
+data ModuleDirective =
+  ModuleDirectiveRequires ModuleDirective_Requires |
+  ModuleDirectiveExports ModuleDirective_ExportsOrOpens |
+  ModuleDirectiveOpens ModuleDirective_ExportsOrOpens |
+  ModuleDirectiveUses TypeName |
+  ModuleDirectiveProvides ModuleDirective_Provides
+  deriving (Eq, Ord, Read, Show)
+
+_ModuleDirective = Core.Name "hydra.java.syntax.ModuleDirective"
+
+_ModuleDirective_requires = Core.Name "requires"
+
+_ModuleDirective_exports = Core.Name "exports"
+
+_ModuleDirective_opens = Core.Name "opens"
+
+_ModuleDirective_uses = Core.Name "uses"
+
+_ModuleDirective_provides = Core.Name "provides"
+
+data ModuleDirective_Requires =
+  ModuleDirective_Requires {
+    moduleDirective_RequiresModifiers :: [RequiresModifier],
+    moduleDirective_RequiresModule :: ModuleName}
+  deriving (Eq, Ord, Read, Show)
+
+_ModuleDirective_Requires = Core.Name "hydra.java.syntax.ModuleDirective_Requires"
+
+_ModuleDirective_Requires_modifiers = Core.Name "modifiers"
+
+_ModuleDirective_Requires_module = Core.Name "module"
+
+data ModuleDirective_ExportsOrOpens =
+  ModuleDirective_ExportsOrOpens {
+    moduleDirective_ExportsOrOpensPackage :: PackageName,
+    -- | At least one module
+    moduleDirective_ExportsOrOpensModules :: [ModuleName]}
+  deriving (Eq, Ord, Read, Show)
+
+_ModuleDirective_ExportsOrOpens = Core.Name "hydra.java.syntax.ModuleDirective_ExportsOrOpens"
+
+_ModuleDirective_ExportsOrOpens_package = Core.Name "package"
+
+_ModuleDirective_ExportsOrOpens_modules = Core.Name "modules"
+
+data ModuleDirective_Provides =
+  ModuleDirective_Provides {
+    moduleDirective_ProvidesTo :: TypeName,
+    -- | At least one type
+    moduleDirective_ProvidesWith :: [TypeName]}
+  deriving (Eq, Ord, Read, Show)
+
+_ModuleDirective_Provides = Core.Name "hydra.java.syntax.ModuleDirective_Provides"
+
+_ModuleDirective_Provides_to = Core.Name "to"
+
+_ModuleDirective_Provides_with = Core.Name "with"
+
+data RequiresModifier =
+  RequiresModifierTransitive |
+  RequiresModifierStatic
+  deriving (Eq, Ord, Read, Show)
+
+_RequiresModifier = Core.Name "hydra.java.syntax.RequiresModifier"
+
+_RequiresModifier_transitive = Core.Name "transitive"
+
+_RequiresModifier_static = Core.Name "static"
+
+data ClassDeclaration =
+  ClassDeclarationNormal NormalClassDeclaration |
+  ClassDeclarationEnum EnumDeclaration |
+  ClassDeclarationRecord RecordDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_ClassDeclaration = Core.Name "hydra.java.syntax.ClassDeclaration"
+
+_ClassDeclaration_normal = Core.Name "normal"
+
+_ClassDeclaration_enum = Core.Name "enum"
+
+_ClassDeclaration_record = Core.Name "record"
+
+data NormalClassDeclaration =
+  NormalClassDeclaration {
+    normalClassDeclarationModifiers :: [ClassModifier],
+    normalClassDeclarationIdentifier :: TypeIdentifier,
+    normalClassDeclarationParameters :: [TypeParameter],
+    normalClassDeclarationExtends :: (Maybe ClassType),
+    normalClassDeclarationImplements :: [InterfaceType],
+    normalClassDeclarationPermits :: [TypeName],
+    normalClassDeclarationBody :: ClassBody}
+  deriving (Eq, Ord, Read, Show)
+
+_NormalClassDeclaration = Core.Name "hydra.java.syntax.NormalClassDeclaration"
+
+_NormalClassDeclaration_modifiers = Core.Name "modifiers"
+
+_NormalClassDeclaration_identifier = Core.Name "identifier"
+
+_NormalClassDeclaration_parameters = Core.Name "parameters"
+
+_NormalClassDeclaration_extends = Core.Name "extends"
+
+_NormalClassDeclaration_implements = Core.Name "implements"
+
+_NormalClassDeclaration_permits = Core.Name "permits"
+
+_NormalClassDeclaration_body = Core.Name "body"
+
+data ClassModifier =
+  ClassModifierAnnotation Annotation |
+  ClassModifierPublic |
+  ClassModifierProtected |
+  ClassModifierPrivate |
+  ClassModifierAbstract |
+  ClassModifierStatic |
+  ClassModifierFinal |
+  ClassModifierSealed |
+  ClassModifierNonSealed |
+  ClassModifierStrictfp
+  deriving (Eq, Ord, Read, Show)
+
+_ClassModifier = Core.Name "hydra.java.syntax.ClassModifier"
+
+_ClassModifier_annotation = Core.Name "annotation"
+
+_ClassModifier_public = Core.Name "public"
+
+_ClassModifier_protected = Core.Name "protected"
+
+_ClassModifier_private = Core.Name "private"
+
+_ClassModifier_abstract = Core.Name "abstract"
+
+_ClassModifier_static = Core.Name "static"
+
+_ClassModifier_final = Core.Name "final"
+
+_ClassModifier_sealed = Core.Name "sealed"
+
+_ClassModifier_nonSealed = Core.Name "nonSealed"
+
+_ClassModifier_strictfp = Core.Name "strictfp"
+
+newtype ClassBody =
+  ClassBody {
+    unClassBody :: [ClassBodyDeclarationWithComments]}
+  deriving (Eq, Ord, Read, Show)
+
+_ClassBody = Core.Name "hydra.java.syntax.ClassBody"
+
+data ClassBodyDeclaration =
+  ClassBodyDeclarationClassMember ClassMemberDeclaration |
+  ClassBodyDeclarationInstanceInitializer InstanceInitializer |
+  ClassBodyDeclarationStaticInitializer StaticInitializer |
+  ClassBodyDeclarationConstructorDeclaration ConstructorDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_ClassBodyDeclaration = Core.Name "hydra.java.syntax.ClassBodyDeclaration"
+
+_ClassBodyDeclaration_classMember = Core.Name "classMember"
+
+_ClassBodyDeclaration_instanceInitializer = Core.Name "instanceInitializer"
+
+_ClassBodyDeclaration_staticInitializer = Core.Name "staticInitializer"
+
+_ClassBodyDeclaration_constructorDeclaration = Core.Name "constructorDeclaration"
+
+data ClassBodyDeclarationWithComments =
+  ClassBodyDeclarationWithComments {
+    classBodyDeclarationWithCommentsValue :: ClassBodyDeclaration,
+    classBodyDeclarationWithCommentsComments :: (Maybe String)}
+  deriving (Eq, Ord, Read, Show)
+
+_ClassBodyDeclarationWithComments = Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"
+
+_ClassBodyDeclarationWithComments_value = Core.Name "value"
+
+_ClassBodyDeclarationWithComments_comments = Core.Name "comments"
+
+data ClassMemberDeclaration =
+  ClassMemberDeclarationField FieldDeclaration |
+  ClassMemberDeclarationMethod MethodDeclaration |
+  ClassMemberDeclarationClass ClassDeclaration |
+  ClassMemberDeclarationInterface InterfaceDeclaration |
+  ClassMemberDeclarationNone
+  deriving (Eq, Ord, Read, Show)
+
+_ClassMemberDeclaration = Core.Name "hydra.java.syntax.ClassMemberDeclaration"
+
+_ClassMemberDeclaration_field = Core.Name "field"
+
+_ClassMemberDeclaration_method = Core.Name "method"
+
+_ClassMemberDeclaration_class = Core.Name "class"
+
+_ClassMemberDeclaration_interface = Core.Name "interface"
+
+_ClassMemberDeclaration_none = Core.Name "none"
+
+data FieldDeclaration =
+  FieldDeclaration {
+    fieldDeclarationModifiers :: [FieldModifier],
+    fieldDeclarationUnannType :: UnannType,
+    fieldDeclarationVariableDeclarators :: [VariableDeclarator]}
+  deriving (Eq, Ord, Read, Show)
+
+_FieldDeclaration = Core.Name "hydra.java.syntax.FieldDeclaration"
+
+_FieldDeclaration_modifiers = Core.Name "modifiers"
+
+_FieldDeclaration_unannType = Core.Name "unannType"
+
+_FieldDeclaration_variableDeclarators = Core.Name "variableDeclarators"
+
+data FieldModifier =
+  FieldModifierAnnotation Annotation |
+  FieldModifierPublic |
+  FieldModifierProtected |
+  FieldModifierPrivate |
+  FieldModifierStatic |
+  FieldModifierFinal |
+  FieldModifierTransient |
+  FieldModifierVolatile
+  deriving (Eq, Ord, Read, Show)
+
+_FieldModifier = Core.Name "hydra.java.syntax.FieldModifier"
+
+_FieldModifier_annotation = Core.Name "annotation"
+
+_FieldModifier_public = Core.Name "public"
+
+_FieldModifier_protected = Core.Name "protected"
+
+_FieldModifier_private = Core.Name "private"
+
+_FieldModifier_static = Core.Name "static"
+
+_FieldModifier_final = Core.Name "final"
+
+_FieldModifier_transient = Core.Name "transient"
+
+_FieldModifier_volatile = Core.Name "volatile"
+
+data VariableDeclarator =
+  VariableDeclarator {
+    variableDeclaratorId :: VariableDeclaratorId,
+    variableDeclaratorInitializer :: (Maybe VariableInitializer)}
+  deriving (Eq, Ord, Read, Show)
+
+_VariableDeclarator = Core.Name "hydra.java.syntax.VariableDeclarator"
+
+_VariableDeclarator_id = Core.Name "id"
+
+_VariableDeclarator_initializer = Core.Name "initializer"
+
+data VariableDeclaratorId =
+  VariableDeclaratorId {
+    variableDeclaratorIdIdentifier :: Identifier,
+    variableDeclaratorIdDims :: (Maybe Dims)}
+  deriving (Eq, Ord, Read, Show)
+
+_VariableDeclaratorId = Core.Name "hydra.java.syntax.VariableDeclaratorId"
+
+_VariableDeclaratorId_identifier = Core.Name "identifier"
+
+_VariableDeclaratorId_dims = Core.Name "dims"
+
+data VariableInitializer =
+  VariableInitializerExpression Expression |
+  VariableInitializerArrayInitializer ArrayInitializer
+  deriving (Eq, Ord, Read, Show)
+
+_VariableInitializer = Core.Name "hydra.java.syntax.VariableInitializer"
+
+_VariableInitializer_expression = Core.Name "expression"
+
+_VariableInitializer_arrayInitializer = Core.Name "arrayInitializer"
+
+-- | A Type which does not allow annotations
+newtype UnannType =
+  UnannType {
+    unUnannType :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_UnannType = Core.Name "hydra.java.syntax.UnannType"
+
+-- | A ClassType which does not allow annotations
+newtype UnannClassType =
+  UnannClassType {
+    unUnannClassType :: ClassType}
+  deriving (Eq, Ord, Read, Show)
+
+_UnannClassType = Core.Name "hydra.java.syntax.UnannClassType"
+
+data MethodDeclaration =
+  MethodDeclaration {
+    -- | Note: simple methods cannot have annotations
+    methodDeclarationAnnotations :: [Annotation],
+    methodDeclarationModifiers :: [MethodModifier],
+    methodDeclarationHeader :: MethodHeader,
+    methodDeclarationBody :: MethodBody}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodDeclaration = Core.Name "hydra.java.syntax.MethodDeclaration"
+
+_MethodDeclaration_annotations = Core.Name "annotations"
+
+_MethodDeclaration_modifiers = Core.Name "modifiers"
+
+_MethodDeclaration_header = Core.Name "header"
+
+_MethodDeclaration_body = Core.Name "body"
+
+data MethodModifier =
+  MethodModifierAnnotation Annotation |
+  MethodModifierPublic |
+  MethodModifierProtected |
+  MethodModifierPrivate |
+  MethodModifierAbstract |
+  MethodModifierStatic |
+  MethodModifierFinal |
+  MethodModifierSynchronized |
+  MethodModifierNative |
+  MethodModifierStrictfp
+  deriving (Eq, Ord, Read, Show)
+
+_MethodModifier = Core.Name "hydra.java.syntax.MethodModifier"
+
+_MethodModifier_annotation = Core.Name "annotation"
+
+_MethodModifier_public = Core.Name "public"
+
+_MethodModifier_protected = Core.Name "protected"
+
+_MethodModifier_private = Core.Name "private"
+
+_MethodModifier_abstract = Core.Name "abstract"
+
+_MethodModifier_static = Core.Name "static"
+
+_MethodModifier_final = Core.Name "final"
+
+_MethodModifier_synchronized = Core.Name "synchronized"
+
+_MethodModifier_native = Core.Name "native"
+
+_MethodModifier_strictfp = Core.Name "strictfp"
+
+data MethodHeader =
+  MethodHeader {
+    methodHeaderParameters :: [TypeParameter],
+    methodHeaderResult :: Result,
+    methodHeaderDeclarator :: MethodDeclarator,
+    methodHeaderThrows :: (Maybe Throws)}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodHeader = Core.Name "hydra.java.syntax.MethodHeader"
+
+_MethodHeader_parameters = Core.Name "parameters"
+
+_MethodHeader_result = Core.Name "result"
+
+_MethodHeader_declarator = Core.Name "declarator"
+
+_MethodHeader_throws = Core.Name "throws"
+
+data Result =
+  ResultType UnannType |
+  ResultVoid
+  deriving (Eq, Ord, Read, Show)
+
+_Result = Core.Name "hydra.java.syntax.Result"
+
+_Result_type = Core.Name "type"
+
+_Result_void = Core.Name "void"
+
+data MethodDeclarator =
+  MethodDeclarator {
+    methodDeclaratorIdentifier :: Identifier,
+    methodDeclaratorReceiverParameter :: (Maybe ReceiverParameter),
+    methodDeclaratorFormalParameters :: [FormalParameter]}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodDeclarator = Core.Name "hydra.java.syntax.MethodDeclarator"
+
+_MethodDeclarator_identifier = Core.Name "identifier"
+
+_MethodDeclarator_receiverParameter = Core.Name "receiverParameter"
+
+_MethodDeclarator_formalParameters = Core.Name "formalParameters"
+
+data ReceiverParameter =
+  ReceiverParameter {
+    receiverParameterAnnotations :: [Annotation],
+    receiverParameterUnannType :: UnannType,
+    receiverParameterIdentifier :: (Maybe Identifier)}
+  deriving (Eq, Ord, Read, Show)
+
+_ReceiverParameter = Core.Name "hydra.java.syntax.ReceiverParameter"
+
+_ReceiverParameter_annotations = Core.Name "annotations"
+
+_ReceiverParameter_unannType = Core.Name "unannType"
+
+_ReceiverParameter_identifier = Core.Name "identifier"
+
+data FormalParameter =
+  FormalParameterSimple FormalParameter_Simple |
+  FormalParameterVariableArity VariableArityParameter
+  deriving (Eq, Ord, Read, Show)
+
+_FormalParameter = Core.Name "hydra.java.syntax.FormalParameter"
+
+_FormalParameter_simple = Core.Name "simple"
+
+_FormalParameter_variableArity = Core.Name "variableArity"
+
+data FormalParameter_Simple =
+  FormalParameter_Simple {
+    formalParameter_SimpleModifiers :: [VariableModifier],
+    formalParameter_SimpleType :: UnannType,
+    formalParameter_SimpleId :: VariableDeclaratorId}
+  deriving (Eq, Ord, Read, Show)
+
+_FormalParameter_Simple = Core.Name "hydra.java.syntax.FormalParameter_Simple"
+
+_FormalParameter_Simple_modifiers = Core.Name "modifiers"
+
+_FormalParameter_Simple_type = Core.Name "type"
+
+_FormalParameter_Simple_id = Core.Name "id"
+
+data VariableArityParameter =
+  VariableArityParameter {
+    variableArityParameterModifiers :: [VariableModifier],
+    variableArityParameterType :: UnannType,
+    variableArityParameterAnnotations :: [Annotation],
+    variableArityParameterIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_VariableArityParameter = Core.Name "hydra.java.syntax.VariableArityParameter"
+
+_VariableArityParameter_modifiers = Core.Name "modifiers"
+
+_VariableArityParameter_type = Core.Name "type"
+
+_VariableArityParameter_annotations = Core.Name "annotations"
+
+_VariableArityParameter_identifier = Core.Name "identifier"
+
+data VariableModifier =
+  VariableModifierAnnotation Annotation |
+  VariableModifierFinal
+  deriving (Eq, Ord, Read, Show)
+
+_VariableModifier = Core.Name "hydra.java.syntax.VariableModifier"
+
+_VariableModifier_annotation = Core.Name "annotation"
+
+_VariableModifier_final = Core.Name "final"
+
+newtype Throws =
+  Throws {
+    unThrows :: [ExceptionType]}
+  deriving (Eq, Ord, Read, Show)
+
+_Throws = Core.Name "hydra.java.syntax.Throws"
+
+data ExceptionType =
+  ExceptionTypeClass ClassType |
+  ExceptionTypeVariable TypeVariable
+  deriving (Eq, Ord, Read, Show)
+
+_ExceptionType = Core.Name "hydra.java.syntax.ExceptionType"
+
+_ExceptionType_class = Core.Name "class"
+
+_ExceptionType_variable = Core.Name "variable"
+
+data MethodBody =
+  MethodBodyBlock Block |
+  MethodBodyNone
+  deriving (Eq, Ord, Read, Show)
+
+_MethodBody = Core.Name "hydra.java.syntax.MethodBody"
+
+_MethodBody_block = Core.Name "block"
+
+_MethodBody_none = Core.Name "none"
+
+newtype InstanceInitializer =
+  InstanceInitializer {
+    unInstanceInitializer :: Block}
+  deriving (Eq, Ord, Read, Show)
+
+_InstanceInitializer = Core.Name "hydra.java.syntax.InstanceInitializer"
+
+newtype StaticInitializer =
+  StaticInitializer {
+    unStaticInitializer :: Block}
+  deriving (Eq, Ord, Read, Show)
+
+_StaticInitializer = Core.Name "hydra.java.syntax.StaticInitializer"
+
+data ConstructorDeclaration =
+  ConstructorDeclaration {
+    constructorDeclarationModifiers :: [ConstructorModifier],
+    constructorDeclarationConstructor :: ConstructorDeclarator,
+    constructorDeclarationThrows :: (Maybe Throws),
+    constructorDeclarationBody :: ConstructorBody}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstructorDeclaration = Core.Name "hydra.java.syntax.ConstructorDeclaration"
+
+_ConstructorDeclaration_modifiers = Core.Name "modifiers"
+
+_ConstructorDeclaration_constructor = Core.Name "constructor"
+
+_ConstructorDeclaration_throws = Core.Name "throws"
+
+_ConstructorDeclaration_body = Core.Name "body"
+
+data ConstructorModifier =
+  ConstructorModifierAnnotation Annotation |
+  ConstructorModifierPublic |
+  ConstructorModifierProtected |
+  ConstructorModifierPrivate
+  deriving (Eq, Ord, Read, Show)
+
+_ConstructorModifier = Core.Name "hydra.java.syntax.ConstructorModifier"
+
+_ConstructorModifier_annotation = Core.Name "annotation"
+
+_ConstructorModifier_public = Core.Name "public"
+
+_ConstructorModifier_protected = Core.Name "protected"
+
+_ConstructorModifier_private = Core.Name "private"
+
+data ConstructorDeclarator =
+  ConstructorDeclarator {
+    constructorDeclaratorParameters :: [TypeParameter],
+    constructorDeclaratorName :: SimpleTypeName,
+    constructorDeclaratorReceiverParameter :: (Maybe ReceiverParameter),
+    constructorDeclaratorFormalParameters :: [FormalParameter]}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstructorDeclarator = Core.Name "hydra.java.syntax.ConstructorDeclarator"
+
+_ConstructorDeclarator_parameters = Core.Name "parameters"
+
+_ConstructorDeclarator_name = Core.Name "name"
+
+_ConstructorDeclarator_receiverParameter = Core.Name "receiverParameter"
+
+_ConstructorDeclarator_formalParameters = Core.Name "formalParameters"
+
+newtype SimpleTypeName =
+  SimpleTypeName {
+    unSimpleTypeName :: TypeIdentifier}
+  deriving (Eq, Ord, Read, Show)
+
+_SimpleTypeName = Core.Name "hydra.java.syntax.SimpleTypeName"
+
+data ConstructorBody =
+  ConstructorBody {
+    constructorBodyInvocation :: (Maybe ExplicitConstructorInvocation),
+    constructorBodyStatements :: [BlockStatement]}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstructorBody = Core.Name "hydra.java.syntax.ConstructorBody"
+
+_ConstructorBody_invocation = Core.Name "invocation"
+
+_ConstructorBody_statements = Core.Name "statements"
+
+data ExplicitConstructorInvocation =
+  ExplicitConstructorInvocation {
+    explicitConstructorInvocationTypeArguments :: [TypeArgument],
+    explicitConstructorInvocationArguments :: [Expression],
+    explicitConstructorInvocationVariant :: ExplicitConstructorInvocation_Variant}
+  deriving (Eq, Ord, Read, Show)
+
+_ExplicitConstructorInvocation = Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"
+
+_ExplicitConstructorInvocation_typeArguments = Core.Name "typeArguments"
+
+_ExplicitConstructorInvocation_arguments = Core.Name "arguments"
+
+_ExplicitConstructorInvocation_variant = Core.Name "variant"
+
+data ExplicitConstructorInvocation_Variant =
+  ExplicitConstructorInvocation_VariantThis |
+  ExplicitConstructorInvocation_VariantSuper (Maybe ExpressionName) |
+  ExplicitConstructorInvocation_VariantPrimary Primary
+  deriving (Eq, Ord, Read, Show)
+
+_ExplicitConstructorInvocation_Variant = Core.Name "hydra.java.syntax.ExplicitConstructorInvocation_Variant"
+
+_ExplicitConstructorInvocation_Variant_this = Core.Name "this"
+
+_ExplicitConstructorInvocation_Variant_super = Core.Name "super"
+
+_ExplicitConstructorInvocation_Variant_primary = Core.Name "primary"
+
+data EnumDeclaration =
+  EnumDeclaration {
+    enumDeclarationModifiers :: [ClassModifier],
+    enumDeclarationIdentifier :: TypeIdentifier,
+    enumDeclarationImplements :: [InterfaceType],
+    enumDeclarationBody :: EnumBody}
+  deriving (Eq, Ord, Read, Show)
+
+_EnumDeclaration = Core.Name "hydra.java.syntax.EnumDeclaration"
+
+_EnumDeclaration_modifiers = Core.Name "modifiers"
+
+_EnumDeclaration_identifier = Core.Name "identifier"
+
+_EnumDeclaration_implements = Core.Name "implements"
+
+_EnumDeclaration_body = Core.Name "body"
+
+newtype EnumBody =
+  EnumBody {
+    unEnumBody :: [EnumBody_Element]}
+  deriving (Eq, Ord, Read, Show)
+
+_EnumBody = Core.Name "hydra.java.syntax.EnumBody"
+
+data EnumBody_Element =
+  EnumBody_Element {
+    enumBody_ElementConstants :: [EnumConstant],
+    enumBody_ElementBodyDeclarations :: [ClassBodyDeclaration]}
+  deriving (Eq, Ord, Read, Show)
+
+_EnumBody_Element = Core.Name "hydra.java.syntax.EnumBody_Element"
+
+_EnumBody_Element_constants = Core.Name "constants"
+
+_EnumBody_Element_bodyDeclarations = Core.Name "bodyDeclarations"
+
+data EnumConstant =
+  EnumConstant {
+    enumConstantModifiers :: [EnumConstantModifier],
+    enumConstantIdentifier :: Identifier,
+    enumConstantArguments :: (Maybe [Expression]),
+    enumConstantBody :: (Maybe ClassBody)}
+  deriving (Eq, Ord, Read, Show)
+
+_EnumConstant = Core.Name "hydra.java.syntax.EnumConstant"
+
+_EnumConstant_modifiers = Core.Name "modifiers"
+
+_EnumConstant_identifier = Core.Name "identifier"
+
+_EnumConstant_arguments = Core.Name "arguments"
+
+_EnumConstant_body = Core.Name "body"
+
+newtype EnumConstantModifier =
+  EnumConstantModifier {
+    unEnumConstantModifier :: Annotation}
+  deriving (Eq, Ord, Read, Show)
+
+_EnumConstantModifier = Core.Name "hydra.java.syntax.EnumConstantModifier"
+
+data RecordDeclaration =
+  RecordDeclaration {
+    recordDeclarationModifiers :: [ClassModifier],
+    recordDeclarationIdentifier :: TypeIdentifier,
+    recordDeclarationParameters :: [TypeParameter],
+    recordDeclarationHeader :: RecordHeader,
+    recordDeclarationImplements :: [InterfaceType],
+    recordDeclarationBody :: RecordBody}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordDeclaration = Core.Name "hydra.java.syntax.RecordDeclaration"
+
+_RecordDeclaration_modifiers = Core.Name "modifiers"
+
+_RecordDeclaration_identifier = Core.Name "identifier"
+
+_RecordDeclaration_parameters = Core.Name "parameters"
+
+_RecordDeclaration_header = Core.Name "header"
+
+_RecordDeclaration_implements = Core.Name "implements"
+
+_RecordDeclaration_body = Core.Name "body"
+
+newtype RecordHeader =
+  RecordHeader {
+    unRecordHeader :: [RecordComponent]}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordHeader = Core.Name "hydra.java.syntax.RecordHeader"
+
+data RecordComponent =
+  RecordComponentSimple RecordComponent_Simple |
+  RecordComponentVariableArity VariableArityRecordComponent
+  deriving (Eq, Ord, Read, Show)
+
+_RecordComponent = Core.Name "hydra.java.syntax.RecordComponent"
+
+_RecordComponent_simple = Core.Name "simple"
+
+_RecordComponent_variableArity = Core.Name "variableArity"
+
+data RecordComponent_Simple =
+  RecordComponent_Simple {
+    recordComponent_SimpleModifiers :: [RecordComponentModifier],
+    recordComponent_SimpleType :: UnannType,
+    recordComponent_SimpleIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordComponent_Simple = Core.Name "hydra.java.syntax.RecordComponent_Simple"
+
+_RecordComponent_Simple_modifiers = Core.Name "modifiers"
+
+_RecordComponent_Simple_type = Core.Name "type"
+
+_RecordComponent_Simple_identifier = Core.Name "identifier"
+
+data VariableArityRecordComponent =
+  VariableArityRecordComponent {
+    variableArityRecordComponentModifiers :: [RecordComponentModifier],
+    variableArityRecordComponentType :: UnannType,
+    variableArityRecordComponentAnnotations :: [Annotation],
+    variableArityRecordComponentIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_VariableArityRecordComponent = Core.Name "hydra.java.syntax.VariableArityRecordComponent"
+
+_VariableArityRecordComponent_modifiers = Core.Name "modifiers"
+
+_VariableArityRecordComponent_type = Core.Name "type"
+
+_VariableArityRecordComponent_annotations = Core.Name "annotations"
+
+_VariableArityRecordComponent_identifier = Core.Name "identifier"
+
+newtype RecordComponentModifier =
+  RecordComponentModifier {
+    unRecordComponentModifier :: Annotation}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordComponentModifier = Core.Name "hydra.java.syntax.RecordComponentModifier"
+
+newtype RecordBody =
+  RecordBody {
+    unRecordBody :: [RecordBodyDeclaration]}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordBody = Core.Name "hydra.java.syntax.RecordBody"
+
+data RecordBodyDeclaration =
+  RecordBodyDeclarationClassBody ClassBodyDeclaration |
+  RecordBodyDeclarationCompactConstructor CompactConstructorDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_RecordBodyDeclaration = Core.Name "hydra.java.syntax.RecordBodyDeclaration"
+
+_RecordBodyDeclaration_classBody = Core.Name "classBody"
+
+_RecordBodyDeclaration_compactConstructor = Core.Name "compactConstructor"
+
+data CompactConstructorDeclaration =
+  CompactConstructorDeclaration {
+    compactConstructorDeclarationModifiers :: [ConstructorModifier],
+    compactConstructorDeclarationName :: SimpleTypeName,
+    compactConstructorDeclarationBody :: ConstructorBody}
+  deriving (Eq, Ord, Read, Show)
+
+_CompactConstructorDeclaration = Core.Name "hydra.java.syntax.CompactConstructorDeclaration"
+
+_CompactConstructorDeclaration_modifiers = Core.Name "modifiers"
+
+_CompactConstructorDeclaration_name = Core.Name "name"
+
+_CompactConstructorDeclaration_body = Core.Name "body"
+
+data InterfaceDeclaration =
+  InterfaceDeclarationNormalInterface NormalInterfaceDeclaration |
+  InterfaceDeclarationAnnotationInterface AnnotationInterfaceDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceDeclaration = Core.Name "hydra.java.syntax.InterfaceDeclaration"
+
+_InterfaceDeclaration_normalInterface = Core.Name "normalInterface"
+
+_InterfaceDeclaration_annotationInterface = Core.Name "annotationInterface"
+
+data NormalInterfaceDeclaration =
+  NormalInterfaceDeclaration {
+    normalInterfaceDeclarationModifiers :: [InterfaceModifier],
+    normalInterfaceDeclarationIdentifier :: TypeIdentifier,
+    normalInterfaceDeclarationParameters :: [TypeParameter],
+    normalInterfaceDeclarationExtends :: [InterfaceType],
+    normalInterfaceDeclarationPermits :: [TypeName],
+    normalInterfaceDeclarationBody :: InterfaceBody}
+  deriving (Eq, Ord, Read, Show)
+
+_NormalInterfaceDeclaration = Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"
+
+_NormalInterfaceDeclaration_modifiers = Core.Name "modifiers"
+
+_NormalInterfaceDeclaration_identifier = Core.Name "identifier"
+
+_NormalInterfaceDeclaration_parameters = Core.Name "parameters"
+
+_NormalInterfaceDeclaration_extends = Core.Name "extends"
+
+_NormalInterfaceDeclaration_permits = Core.Name "permits"
+
+_NormalInterfaceDeclaration_body = Core.Name "body"
+
+data InterfaceModifier =
+  InterfaceModifierAnnotation Annotation |
+  InterfaceModifierPublic |
+  InterfaceModifierProtected |
+  InterfaceModifierPrivate |
+  InterfaceModifierAbstract |
+  InterfaceModifierStatic |
+  InterfaceModifierSealed |
+  InterfaceModifierNonSealed |
+  InterfaceModifierStrictfp
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceModifier = Core.Name "hydra.java.syntax.InterfaceModifier"
+
+_InterfaceModifier_annotation = Core.Name "annotation"
+
+_InterfaceModifier_public = Core.Name "public"
+
+_InterfaceModifier_protected = Core.Name "protected"
+
+_InterfaceModifier_private = Core.Name "private"
+
+_InterfaceModifier_abstract = Core.Name "abstract"
+
+_InterfaceModifier_static = Core.Name "static"
+
+_InterfaceModifier_sealed = Core.Name "sealed"
+
+_InterfaceModifier_nonSealed = Core.Name "nonSealed"
+
+_InterfaceModifier_strictfp = Core.Name "strictfp"
+
+newtype InterfaceBody =
+  InterfaceBody {
+    unInterfaceBody :: [InterfaceMemberDeclarationWithComments]}
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceBody = Core.Name "hydra.java.syntax.InterfaceBody"
+
+data InterfaceMemberDeclaration =
+  InterfaceMemberDeclarationConstant ConstantDeclaration |
+  InterfaceMemberDeclarationInterfaceMethod InterfaceMethodDeclaration |
+  InterfaceMemberDeclarationClass ClassDeclaration |
+  InterfaceMemberDeclarationInterface InterfaceDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceMemberDeclaration = Core.Name "hydra.java.syntax.InterfaceMemberDeclaration"
+
+_InterfaceMemberDeclaration_constant = Core.Name "constant"
+
+_InterfaceMemberDeclaration_interfaceMethod = Core.Name "interfaceMethod"
+
+_InterfaceMemberDeclaration_class = Core.Name "class"
+
+_InterfaceMemberDeclaration_interface = Core.Name "interface"
+
+data InterfaceMemberDeclarationWithComments =
+  InterfaceMemberDeclarationWithComments {
+    interfaceMemberDeclarationWithCommentsValue :: InterfaceMemberDeclaration,
+    interfaceMemberDeclarationWithCommentsComments :: (Maybe String)}
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceMemberDeclarationWithComments = Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"
+
+_InterfaceMemberDeclarationWithComments_value = Core.Name "value"
+
+_InterfaceMemberDeclarationWithComments_comments = Core.Name "comments"
+
+data ConstantDeclaration =
+  ConstantDeclaration {
+    constantDeclarationModifiers :: [ConstantModifier],
+    constantDeclarationType :: UnannType,
+    constantDeclarationVariables :: [VariableDeclarator]}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstantDeclaration = Core.Name "hydra.java.syntax.ConstantDeclaration"
+
+_ConstantDeclaration_modifiers = Core.Name "modifiers"
+
+_ConstantDeclaration_type = Core.Name "type"
+
+_ConstantDeclaration_variables = Core.Name "variables"
+
+data ConstantModifier =
+  ConstantModifierAnnotation Annotation |
+  ConstantModifierPublic |
+  ConstantModifierStatic |
+  ConstantModifierFinal
+  deriving (Eq, Ord, Read, Show)
+
+_ConstantModifier = Core.Name "hydra.java.syntax.ConstantModifier"
+
+_ConstantModifier_annotation = Core.Name "annotation"
+
+_ConstantModifier_public = Core.Name "public"
+
+_ConstantModifier_static = Core.Name "static"
+
+_ConstantModifier_final = Core.Name "final"
+
+data InterfaceMethodDeclaration =
+  InterfaceMethodDeclaration {
+    interfaceMethodDeclarationModifiers :: [InterfaceMethodModifier],
+    interfaceMethodDeclarationHeader :: MethodHeader,
+    interfaceMethodDeclarationBody :: MethodBody}
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceMethodDeclaration = Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"
+
+_InterfaceMethodDeclaration_modifiers = Core.Name "modifiers"
+
+_InterfaceMethodDeclaration_header = Core.Name "header"
+
+_InterfaceMethodDeclaration_body = Core.Name "body"
+
+data InterfaceMethodModifier =
+  InterfaceMethodModifierAnnotation Annotation |
+  InterfaceMethodModifierPublic |
+  InterfaceMethodModifierPrivate |
+  InterfaceMethodModifierAbstract |
+  InterfaceMethodModifierDefault |
+  InterfaceMethodModifierStatic |
+  InterfaceMethodModifierStrictfp
+  deriving (Eq, Ord, Read, Show)
+
+_InterfaceMethodModifier = Core.Name "hydra.java.syntax.InterfaceMethodModifier"
+
+_InterfaceMethodModifier_annotation = Core.Name "annotation"
+
+_InterfaceMethodModifier_public = Core.Name "public"
+
+_InterfaceMethodModifier_private = Core.Name "private"
+
+_InterfaceMethodModifier_abstract = Core.Name "abstract"
+
+_InterfaceMethodModifier_default = Core.Name "default"
+
+_InterfaceMethodModifier_static = Core.Name "static"
+
+_InterfaceMethodModifier_strictfp = Core.Name "strictfp"
+
+data AnnotationInterfaceDeclaration =
+  AnnotationInterfaceDeclaration {
+    annotationInterfaceDeclarationModifiers :: [InterfaceModifier],
+    annotationInterfaceDeclarationIdentifier :: TypeIdentifier,
+    annotationInterfaceDeclarationBody :: AnnotationInterfaceBody}
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotationInterfaceDeclaration = Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"
+
+_AnnotationInterfaceDeclaration_modifiers = Core.Name "modifiers"
+
+_AnnotationInterfaceDeclaration_identifier = Core.Name "identifier"
+
+_AnnotationInterfaceDeclaration_body = Core.Name "body"
+
+newtype AnnotationInterfaceBody =
+  AnnotationInterfaceBody {
+    unAnnotationInterfaceBody :: [AnnotationInterfaceMemberDeclaration]}
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotationInterfaceBody = Core.Name "hydra.java.syntax.AnnotationInterfaceBody"
+
+data AnnotationInterfaceMemberDeclaration =
+  AnnotationInterfaceMemberDeclarationAnnotationInterface AnnotationInterfaceElementDeclaration |
+  AnnotationInterfaceMemberDeclarationConstant ConstantDeclaration |
+  AnnotationInterfaceMemberDeclarationClass ClassDeclaration |
+  AnnotationInterfaceMemberDeclarationInterface InterfaceDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotationInterfaceMemberDeclaration = Core.Name "hydra.java.syntax.AnnotationInterfaceMemberDeclaration"
+
+_AnnotationInterfaceMemberDeclaration_annotationInterface = Core.Name "annotationInterface"
+
+_AnnotationInterfaceMemberDeclaration_constant = Core.Name "constant"
+
+_AnnotationInterfaceMemberDeclaration_class = Core.Name "class"
+
+_AnnotationInterfaceMemberDeclaration_interface = Core.Name "interface"
+
+data AnnotationInterfaceElementDeclaration =
+  AnnotationInterfaceElementDeclaration {
+    annotationInterfaceElementDeclarationModifiers :: [AnnotationInterfaceElementModifier],
+    annotationInterfaceElementDeclarationType :: UnannType,
+    annotationInterfaceElementDeclarationIdentifier :: Identifier,
+    annotationInterfaceElementDeclarationDims :: (Maybe Dims),
+    annotationInterfaceElementDeclarationDefault :: (Maybe DefaultValue)}
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotationInterfaceElementDeclaration = Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"
+
+_AnnotationInterfaceElementDeclaration_modifiers = Core.Name "modifiers"
+
+_AnnotationInterfaceElementDeclaration_type = Core.Name "type"
+
+_AnnotationInterfaceElementDeclaration_identifier = Core.Name "identifier"
+
+_AnnotationInterfaceElementDeclaration_dims = Core.Name "dims"
+
+_AnnotationInterfaceElementDeclaration_default = Core.Name "default"
+
+data AnnotationInterfaceElementModifier =
+  AnnotationInterfaceElementModifierAnnotation Annotation |
+  AnnotationInterfaceElementModifierPublic |
+  AnnotationInterfaceElementModifierAbstract
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotationInterfaceElementModifier = Core.Name "hydra.java.syntax.AnnotationInterfaceElementModifier"
+
+_AnnotationInterfaceElementModifier_annotation = Core.Name "annotation"
+
+_AnnotationInterfaceElementModifier_public = Core.Name "public"
+
+_AnnotationInterfaceElementModifier_abstract = Core.Name "abstract"
+
+newtype DefaultValue =
+  DefaultValue {
+    unDefaultValue :: ElementValue}
+  deriving (Eq, Ord, Read, Show)
+
+_DefaultValue = Core.Name "hydra.java.syntax.DefaultValue"
+
+data Annotation =
+  AnnotationNormal NormalAnnotation |
+  AnnotationMarker MarkerAnnotation |
+  AnnotationSingleElement SingleElementAnnotation
+  deriving (Eq, Ord, Read, Show)
+
+_Annotation = Core.Name "hydra.java.syntax.Annotation"
+
+_Annotation_normal = Core.Name "normal"
+
+_Annotation_marker = Core.Name "marker"
+
+_Annotation_singleElement = Core.Name "singleElement"
+
+data NormalAnnotation =
+  NormalAnnotation {
+    normalAnnotationTypeName :: TypeName,
+    normalAnnotationPairs :: [ElementValuePair]}
+  deriving (Eq, Ord, Read, Show)
+
+_NormalAnnotation = Core.Name "hydra.java.syntax.NormalAnnotation"
+
+_NormalAnnotation_typeName = Core.Name "typeName"
+
+_NormalAnnotation_pairs = Core.Name "pairs"
+
+data ElementValuePair =
+  ElementValuePair {
+    elementValuePairKey :: Identifier,
+    elementValuePairValue :: ElementValue}
+  deriving (Eq, Ord, Read, Show)
+
+_ElementValuePair = Core.Name "hydra.java.syntax.ElementValuePair"
+
+_ElementValuePair_key = Core.Name "key"
+
+_ElementValuePair_value = Core.Name "value"
+
+data ElementValue =
+  ElementValueConditionalExpression ConditionalExpression |
+  ElementValueElementValueArrayInitializer ElementValueArrayInitializer |
+  ElementValueAnnotation Annotation
+  deriving (Eq, Ord, Read, Show)
+
+_ElementValue = Core.Name "hydra.java.syntax.ElementValue"
+
+_ElementValue_conditionalExpression = Core.Name "conditionalExpression"
+
+_ElementValue_elementValueArrayInitializer = Core.Name "elementValueArrayInitializer"
+
+_ElementValue_annotation = Core.Name "annotation"
+
+newtype ElementValueArrayInitializer =
+  ElementValueArrayInitializer {
+    unElementValueArrayInitializer :: [ElementValue]}
+  deriving (Eq, Ord, Read, Show)
+
+_ElementValueArrayInitializer = Core.Name "hydra.java.syntax.ElementValueArrayInitializer"
+
+newtype MarkerAnnotation =
+  MarkerAnnotation {
+    unMarkerAnnotation :: TypeName}
+  deriving (Eq, Ord, Read, Show)
+
+_MarkerAnnotation = Core.Name "hydra.java.syntax.MarkerAnnotation"
+
+data SingleElementAnnotation =
+  SingleElementAnnotation {
+    singleElementAnnotationName :: TypeName,
+    singleElementAnnotationValue :: (Maybe ElementValue)}
+  deriving (Eq, Ord, Read, Show)
+
+_SingleElementAnnotation = Core.Name "hydra.java.syntax.SingleElementAnnotation"
+
+_SingleElementAnnotation_name = Core.Name "name"
+
+_SingleElementAnnotation_value = Core.Name "value"
+
+newtype ArrayInitializer =
+  ArrayInitializer {
+    unArrayInitializer :: [[VariableInitializer]]}
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayInitializer = Core.Name "hydra.java.syntax.ArrayInitializer"
+
+newtype Block =
+  Block {
+    unBlock :: [BlockStatement]}
+  deriving (Eq, Ord, Read, Show)
+
+_Block = Core.Name "hydra.java.syntax.Block"
+
+data BlockStatement =
+  BlockStatementLocalVariableDeclaration LocalVariableDeclarationStatement |
+  BlockStatementLocalClassOrInterface LocalClassOrInterfaceDeclaration |
+  BlockStatementStatement Statement
+  deriving (Eq, Ord, Read, Show)
+
+_BlockStatement = Core.Name "hydra.java.syntax.BlockStatement"
+
+_BlockStatement_localVariableDeclaration = Core.Name "localVariableDeclaration"
+
+_BlockStatement_localClassOrInterface = Core.Name "localClassOrInterface"
+
+_BlockStatement_statement = Core.Name "statement"
+
+data LocalClassOrInterfaceDeclaration =
+  LocalClassOrInterfaceDeclarationClass ClassDeclaration |
+  LocalClassOrInterfaceDeclarationNormalInterface NormalInterfaceDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_LocalClassOrInterfaceDeclaration = Core.Name "hydra.java.syntax.LocalClassOrInterfaceDeclaration"
+
+_LocalClassOrInterfaceDeclaration_class = Core.Name "class"
+
+_LocalClassOrInterfaceDeclaration_normalInterface = Core.Name "normalInterface"
+
+newtype LocalVariableDeclarationStatement =
+  LocalVariableDeclarationStatement {
+    unLocalVariableDeclarationStatement :: LocalVariableDeclaration}
+  deriving (Eq, Ord, Read, Show)
+
+_LocalVariableDeclarationStatement = Core.Name "hydra.java.syntax.LocalVariableDeclarationStatement"
+
+data LocalVariableDeclaration =
+  LocalVariableDeclaration {
+    localVariableDeclarationModifiers :: [VariableModifier],
+    localVariableDeclarationType :: LocalVariableType,
+    localVariableDeclarationDeclarators :: [VariableDeclarator]}
+  deriving (Eq, Ord, Read, Show)
+
+_LocalVariableDeclaration = Core.Name "hydra.java.syntax.LocalVariableDeclaration"
+
+_LocalVariableDeclaration_modifiers = Core.Name "modifiers"
+
+_LocalVariableDeclaration_type = Core.Name "type"
+
+_LocalVariableDeclaration_declarators = Core.Name "declarators"
+
+data LocalVariableType =
+  LocalVariableTypeType UnannType |
+  LocalVariableTypeVar
+  deriving (Eq, Ord, Read, Show)
+
+_LocalVariableType = Core.Name "hydra.java.syntax.LocalVariableType"
+
+_LocalVariableType_type = Core.Name "type"
+
+_LocalVariableType_var = Core.Name "var"
+
+data Statement =
+  StatementWithoutTrailing StatementWithoutTrailingSubstatement |
+  StatementLabeled LabeledStatement |
+  StatementIfThen IfThenStatement |
+  StatementIfThenElse IfThenElseStatement |
+  StatementWhile WhileStatement |
+  StatementFor ForStatement
+  deriving (Eq, Ord, Read, Show)
+
+_Statement = Core.Name "hydra.java.syntax.Statement"
+
+_Statement_withoutTrailing = Core.Name "withoutTrailing"
+
+_Statement_labeled = Core.Name "labeled"
+
+_Statement_ifThen = Core.Name "ifThen"
+
+_Statement_ifThenElse = Core.Name "ifThenElse"
+
+_Statement_while = Core.Name "while"
+
+_Statement_for = Core.Name "for"
+
+data StatementNoShortIf =
+  StatementNoShortIfWithoutTrailing StatementWithoutTrailingSubstatement |
+  StatementNoShortIfLabeled LabeledStatementNoShortIf |
+  StatementNoShortIfIfThenElse IfThenElseStatementNoShortIf |
+  StatementNoShortIfWhile WhileStatementNoShortIf |
+  StatementNoShortIfFor ForStatementNoShortIf
+  deriving (Eq, Ord, Read, Show)
+
+_StatementNoShortIf = Core.Name "hydra.java.syntax.StatementNoShortIf"
+
+_StatementNoShortIf_withoutTrailing = Core.Name "withoutTrailing"
+
+_StatementNoShortIf_labeled = Core.Name "labeled"
+
+_StatementNoShortIf_ifThenElse = Core.Name "ifThenElse"
+
+_StatementNoShortIf_while = Core.Name "while"
+
+_StatementNoShortIf_for = Core.Name "for"
+
+data StatementWithoutTrailingSubstatement =
+  StatementWithoutTrailingSubstatementBlock Block |
+  StatementWithoutTrailingSubstatementEmpty |
+  StatementWithoutTrailingSubstatementExpression ExpressionStatement |
+  StatementWithoutTrailingSubstatementAssert AssertStatement |
+  StatementWithoutTrailingSubstatementSwitch SwitchStatement |
+  StatementWithoutTrailingSubstatementDo DoStatement |
+  StatementWithoutTrailingSubstatementBreak BreakStatement |
+  StatementWithoutTrailingSubstatementContinue ContinueStatement |
+  StatementWithoutTrailingSubstatementReturn ReturnStatement |
+  StatementWithoutTrailingSubstatementSynchronized SynchronizedStatement |
+  StatementWithoutTrailingSubstatementThrow ThrowStatement |
+  StatementWithoutTrailingSubstatementTry TryStatement |
+  StatementWithoutTrailingSubstatementYield YieldStatement
+  deriving (Eq, Ord, Read, Show)
+
+_StatementWithoutTrailingSubstatement = Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"
+
+_StatementWithoutTrailingSubstatement_block = Core.Name "block"
+
+_StatementWithoutTrailingSubstatement_empty = Core.Name "empty"
+
+_StatementWithoutTrailingSubstatement_expression = Core.Name "expression"
+
+_StatementWithoutTrailingSubstatement_assert = Core.Name "assert"
+
+_StatementWithoutTrailingSubstatement_switch = Core.Name "switch"
+
+_StatementWithoutTrailingSubstatement_do = Core.Name "do"
+
+_StatementWithoutTrailingSubstatement_break = Core.Name "break"
+
+_StatementWithoutTrailingSubstatement_continue = Core.Name "continue"
+
+_StatementWithoutTrailingSubstatement_return = Core.Name "return"
+
+_StatementWithoutTrailingSubstatement_synchronized = Core.Name "synchronized"
+
+_StatementWithoutTrailingSubstatement_throw = Core.Name "throw"
+
+_StatementWithoutTrailingSubstatement_try = Core.Name "try"
+
+_StatementWithoutTrailingSubstatement_yield = Core.Name "yield"
+
+data LabeledStatement =
+  LabeledStatement {
+    labeledStatementIdentifier :: Identifier,
+    labeledStatementStatement :: Statement}
+  deriving (Eq, Ord, Read, Show)
+
+_LabeledStatement = Core.Name "hydra.java.syntax.LabeledStatement"
+
+_LabeledStatement_identifier = Core.Name "identifier"
+
+_LabeledStatement_statement = Core.Name "statement"
+
+data LabeledStatementNoShortIf =
+  LabeledStatementNoShortIf {
+    labeledStatementNoShortIfIdentifier :: Identifier,
+    labeledStatementNoShortIfStatement :: StatementNoShortIf}
+  deriving (Eq, Ord, Read, Show)
+
+_LabeledStatementNoShortIf = Core.Name "hydra.java.syntax.LabeledStatementNoShortIf"
+
+_LabeledStatementNoShortIf_identifier = Core.Name "identifier"
+
+_LabeledStatementNoShortIf_statement = Core.Name "statement"
+
+newtype ExpressionStatement =
+  ExpressionStatement {
+    unExpressionStatement :: StatementExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_ExpressionStatement = Core.Name "hydra.java.syntax.ExpressionStatement"
+
+data StatementExpression =
+  StatementExpressionAssignment Assignment |
+  StatementExpressionPreIncrement PreIncrementExpression |
+  StatementExpressionPreDecrement PreDecrementExpression |
+  StatementExpressionPostIncrement PostIncrementExpression |
+  StatementExpressionPostDecrement PostDecrementExpression |
+  StatementExpressionMethodInvocation MethodInvocation |
+  StatementExpressionClassInstanceCreation ClassInstanceCreationExpression
+  deriving (Eq, Ord, Read, Show)
+
+_StatementExpression = Core.Name "hydra.java.syntax.StatementExpression"
+
+_StatementExpression_assignment = Core.Name "assignment"
+
+_StatementExpression_preIncrement = Core.Name "preIncrement"
+
+_StatementExpression_preDecrement = Core.Name "preDecrement"
+
+_StatementExpression_postIncrement = Core.Name "postIncrement"
+
+_StatementExpression_postDecrement = Core.Name "postDecrement"
+
+_StatementExpression_methodInvocation = Core.Name "methodInvocation"
+
+_StatementExpression_classInstanceCreation = Core.Name "classInstanceCreation"
+
+data IfThenStatement =
+  IfThenStatement {
+    ifThenStatementExpression :: Expression,
+    ifThenStatementStatement :: Statement}
+  deriving (Eq, Ord, Read, Show)
+
+_IfThenStatement = Core.Name "hydra.java.syntax.IfThenStatement"
+
+_IfThenStatement_expression = Core.Name "expression"
+
+_IfThenStatement_statement = Core.Name "statement"
+
+data IfThenElseStatement =
+  IfThenElseStatement {
+    ifThenElseStatementCond :: (Maybe Expression),
+    ifThenElseStatementThen :: StatementNoShortIf,
+    ifThenElseStatementElse :: Statement}
+  deriving (Eq, Ord, Read, Show)
+
+_IfThenElseStatement = Core.Name "hydra.java.syntax.IfThenElseStatement"
+
+_IfThenElseStatement_cond = Core.Name "cond"
+
+_IfThenElseStatement_then = Core.Name "then"
+
+_IfThenElseStatement_else = Core.Name "else"
+
+data IfThenElseStatementNoShortIf =
+  IfThenElseStatementNoShortIf {
+    ifThenElseStatementNoShortIfCond :: (Maybe Expression),
+    ifThenElseStatementNoShortIfThen :: StatementNoShortIf,
+    ifThenElseStatementNoShortIfElse :: StatementNoShortIf}
+  deriving (Eq, Ord, Read, Show)
+
+_IfThenElseStatementNoShortIf = Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"
+
+_IfThenElseStatementNoShortIf_cond = Core.Name "cond"
+
+_IfThenElseStatementNoShortIf_then = Core.Name "then"
+
+_IfThenElseStatementNoShortIf_else = Core.Name "else"
+
+data AssertStatement =
+  AssertStatementSingle Expression |
+  AssertStatementPair AssertStatement_Pair
+  deriving (Eq, Ord, Read, Show)
+
+_AssertStatement = Core.Name "hydra.java.syntax.AssertStatement"
+
+_AssertStatement_single = Core.Name "single"
+
+_AssertStatement_pair = Core.Name "pair"
+
+data AssertStatement_Pair =
+  AssertStatement_Pair {
+    assertStatement_PairFirst :: Expression,
+    assertStatement_PairSecond :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_AssertStatement_Pair = Core.Name "hydra.java.syntax.AssertStatement_Pair"
+
+_AssertStatement_Pair_first = Core.Name "first"
+
+_AssertStatement_Pair_second = Core.Name "second"
+
+data SwitchStatement =
+  SwitchStatement {
+    switchStatementCond :: Expression,
+    switchStatementBlock :: SwitchBlock}
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchStatement = Core.Name "hydra.java.syntax.SwitchStatement"
+
+_SwitchStatement_cond = Core.Name "cond"
+
+_SwitchStatement_block = Core.Name "block"
+
+data SwitchBlock =
+  SwitchBlockRules [SwitchRule] |
+  SwitchBlockLegacy SwitchBlock_Legacy
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchBlock = Core.Name "hydra.java.syntax.SwitchBlock"
+
+_SwitchBlock_rules = Core.Name "rules"
+
+_SwitchBlock_legacy = Core.Name "legacy"
+
+data SwitchBlock_Legacy =
+  SwitchBlock_Legacy {
+    switchBlock_LegacyGroups :: [SwitchBlockStatementGroup],
+    switchBlock_LegacyTrailingLabels :: [SwitchLabel]}
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchBlock_Legacy = Core.Name "hydra.java.syntax.SwitchBlock_Legacy"
+
+_SwitchBlock_Legacy_groups = Core.Name "groups"
+
+_SwitchBlock_Legacy_trailingLabels = Core.Name "trailingLabels"
+
+data SwitchRule =
+  SwitchRule {
+    switchRuleLabel :: SwitchLabel,
+    switchRuleBody :: SwitchRule_Body}
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchRule = Core.Name "hydra.java.syntax.SwitchRule"
+
+_SwitchRule_label = Core.Name "label"
+
+_SwitchRule_body = Core.Name "body"
+
+data SwitchRule_Body =
+  SwitchRule_BodyExpression Expression |
+  SwitchRule_BodyBlock Block |
+  SwitchRule_BodyThrow ThrowStatement
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchRule_Body = Core.Name "hydra.java.syntax.SwitchRule_Body"
+
+_SwitchRule_Body_expression = Core.Name "expression"
+
+_SwitchRule_Body_block = Core.Name "block"
+
+_SwitchRule_Body_throw = Core.Name "throw"
+
+data SwitchBlockStatementGroup =
+  SwitchBlockStatementGroup {
+    switchBlockStatementGroupLabels :: [SwitchLabel],
+    switchBlockStatementGroupStatements :: [BlockStatement]}
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchBlockStatementGroup = Core.Name "hydra.java.syntax.SwitchBlockStatementGroup"
+
+_SwitchBlockStatementGroup_labels = Core.Name "labels"
+
+_SwitchBlockStatementGroup_statements = Core.Name "statements"
+
+data SwitchLabel =
+  SwitchLabelCase [CaseConstant] |
+  SwitchLabelNull Bool |
+  SwitchLabelCasePattern CasePattern |
+  SwitchLabelDefault
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchLabel = Core.Name "hydra.java.syntax.SwitchLabel"
+
+_SwitchLabel_case = Core.Name "case"
+
+_SwitchLabel_null = Core.Name "null"
+
+_SwitchLabel_casePattern = Core.Name "casePattern"
+
+_SwitchLabel_default = Core.Name "default"
+
+newtype CaseConstant =
+  CaseConstant {
+    unCaseConstant :: ConditionalExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_CaseConstant = Core.Name "hydra.java.syntax.CaseConstant"
+
+data CasePattern =
+  CasePattern {
+    casePatternPattern :: Pattern,
+    casePatternGuard :: (Maybe Guard)}
+  deriving (Eq, Ord, Read, Show)
+
+_CasePattern = Core.Name "hydra.java.syntax.CasePattern"
+
+_CasePattern_pattern = Core.Name "pattern"
+
+_CasePattern_guard = Core.Name "guard"
+
+newtype Guard =
+  Guard {
+    unGuard :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_Guard = Core.Name "hydra.java.syntax.Guard"
+
+data Pattern =
+  PatternType TypePattern |
+  PatternRecord RecordPattern
+  deriving (Eq, Ord, Read, Show)
+
+_Pattern = Core.Name "hydra.java.syntax.Pattern"
+
+_Pattern_type = Core.Name "type"
+
+_Pattern_record = Core.Name "record"
+
+newtype TypePattern =
+  TypePattern {
+    unTypePattern :: LocalVariableDeclaration}
+  deriving (Eq, Ord, Read, Show)
+
+_TypePattern = Core.Name "hydra.java.syntax.TypePattern"
+
+data RecordPattern =
+  RecordPattern {
+    recordPatternType :: ReferenceType,
+    recordPatternPatterns :: [Pattern]}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordPattern = Core.Name "hydra.java.syntax.RecordPattern"
+
+_RecordPattern_type = Core.Name "type"
+
+_RecordPattern_patterns = Core.Name "patterns"
+
+data WhileStatement =
+  WhileStatement {
+    whileStatementCond :: (Maybe Expression),
+    whileStatementBody :: Statement}
+  deriving (Eq, Ord, Read, Show)
+
+_WhileStatement = Core.Name "hydra.java.syntax.WhileStatement"
+
+_WhileStatement_cond = Core.Name "cond"
+
+_WhileStatement_body = Core.Name "body"
+
+data WhileStatementNoShortIf =
+  WhileStatementNoShortIf {
+    whileStatementNoShortIfCond :: (Maybe Expression),
+    whileStatementNoShortIfBody :: StatementNoShortIf}
+  deriving (Eq, Ord, Read, Show)
+
+_WhileStatementNoShortIf = Core.Name "hydra.java.syntax.WhileStatementNoShortIf"
+
+_WhileStatementNoShortIf_cond = Core.Name "cond"
+
+_WhileStatementNoShortIf_body = Core.Name "body"
+
+data DoStatement =
+  DoStatement {
+    doStatementBody :: Statement,
+    doStatementCond :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_DoStatement = Core.Name "hydra.java.syntax.DoStatement"
+
+_DoStatement_body = Core.Name "body"
+
+_DoStatement_cond = Core.Name "cond"
+
+data ForStatement =
+  ForStatementBasic BasicForStatement |
+  ForStatementEnhanced EnhancedForStatement
+  deriving (Eq, Ord, Read, Show)
+
+_ForStatement = Core.Name "hydra.java.syntax.ForStatement"
+
+_ForStatement_basic = Core.Name "basic"
+
+_ForStatement_enhanced = Core.Name "enhanced"
+
+data ForStatementNoShortIf =
+  ForStatementNoShortIfBasic BasicForStatementNoShortIf |
+  ForStatementNoShortIfEnhanced EnhancedForStatementNoShortIf
+  deriving (Eq, Ord, Read, Show)
+
+_ForStatementNoShortIf = Core.Name "hydra.java.syntax.ForStatementNoShortIf"
+
+_ForStatementNoShortIf_basic = Core.Name "basic"
+
+_ForStatementNoShortIf_enhanced = Core.Name "enhanced"
+
+data BasicForStatement =
+  BasicForStatement {
+    basicForStatementCond :: ForCond,
+    basicForStatementBody :: Statement}
+  deriving (Eq, Ord, Read, Show)
+
+_BasicForStatement = Core.Name "hydra.java.syntax.BasicForStatement"
+
+_BasicForStatement_cond = Core.Name "cond"
+
+_BasicForStatement_body = Core.Name "body"
+
+data ForCond =
+  ForCond {
+    forCondInit :: (Maybe ForInit),
+    forCondCond :: (Maybe Expression),
+    forCondUpdate :: (Maybe ForUpdate)}
+  deriving (Eq, Ord, Read, Show)
+
+_ForCond = Core.Name "hydra.java.syntax.ForCond"
+
+_ForCond_init = Core.Name "init"
+
+_ForCond_cond = Core.Name "cond"
+
+_ForCond_update = Core.Name "update"
+
+data BasicForStatementNoShortIf =
+  BasicForStatementNoShortIf {
+    basicForStatementNoShortIfCond :: ForCond,
+    basicForStatementNoShortIfBody :: StatementNoShortIf}
+  deriving (Eq, Ord, Read, Show)
+
+_BasicForStatementNoShortIf = Core.Name "hydra.java.syntax.BasicForStatementNoShortIf"
+
+_BasicForStatementNoShortIf_cond = Core.Name "cond"
+
+_BasicForStatementNoShortIf_body = Core.Name "body"
+
+data ForInit =
+  ForInitStatements [StatementExpression] |
+  ForInitLocalVariable LocalVariableDeclaration
+  deriving (Eq, Ord, Read, Show)
+
+_ForInit = Core.Name "hydra.java.syntax.ForInit"
+
+_ForInit_statements = Core.Name "statements"
+
+_ForInit_localVariable = Core.Name "localVariable"
+
+newtype ForUpdate =
+  ForUpdate {
+    unForUpdate :: [StatementExpression]}
+  deriving (Eq, Ord, Read, Show)
+
+_ForUpdate = Core.Name "hydra.java.syntax.ForUpdate"
+
+data EnhancedForStatement =
+  EnhancedForStatement {
+    enhancedForStatementCond :: EnhancedForCond,
+    enhancedForStatementBody :: Statement}
+  deriving (Eq, Ord, Read, Show)
+
+_EnhancedForStatement = Core.Name "hydra.java.syntax.EnhancedForStatement"
+
+_EnhancedForStatement_cond = Core.Name "cond"
+
+_EnhancedForStatement_body = Core.Name "body"
+
+data EnhancedForCond =
+  EnhancedForCond {
+    enhancedForCondDeclaration :: LocalVariableDeclaration,
+    enhancedForCondExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_EnhancedForCond = Core.Name "hydra.java.syntax.EnhancedForCond"
+
+_EnhancedForCond_declaration = Core.Name "declaration"
+
+_EnhancedForCond_expression = Core.Name "expression"
+
+data EnhancedForStatementNoShortIf =
+  EnhancedForStatementNoShortIf {
+    enhancedForStatementNoShortIfCond :: EnhancedForCond,
+    enhancedForStatementNoShortIfBody :: StatementNoShortIf}
+  deriving (Eq, Ord, Read, Show)
+
+_EnhancedForStatementNoShortIf = Core.Name "hydra.java.syntax.EnhancedForStatementNoShortIf"
+
+_EnhancedForStatementNoShortIf_cond = Core.Name "cond"
+
+_EnhancedForStatementNoShortIf_body = Core.Name "body"
+
+newtype BreakStatement =
+  BreakStatement {
+    unBreakStatement :: (Maybe Identifier)}
+  deriving (Eq, Ord, Read, Show)
+
+_BreakStatement = Core.Name "hydra.java.syntax.BreakStatement"
+
+newtype YieldStatement =
+  YieldStatement {
+    unYieldStatement :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_YieldStatement = Core.Name "hydra.java.syntax.YieldStatement"
+
+newtype ContinueStatement =
+  ContinueStatement {
+    unContinueStatement :: (Maybe Identifier)}
+  deriving (Eq, Ord, Read, Show)
+
+_ContinueStatement = Core.Name "hydra.java.syntax.ContinueStatement"
+
+newtype ReturnStatement =
+  ReturnStatement {
+    unReturnStatement :: (Maybe Expression)}
+  deriving (Eq, Ord, Read, Show)
+
+_ReturnStatement = Core.Name "hydra.java.syntax.ReturnStatement"
+
+newtype ThrowStatement =
+  ThrowStatement {
+    unThrowStatement :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_ThrowStatement = Core.Name "hydra.java.syntax.ThrowStatement"
+
+data SynchronizedStatement =
+  SynchronizedStatement {
+    synchronizedStatementExpression :: Expression,
+    synchronizedStatementBlock :: Block}
+  deriving (Eq, Ord, Read, Show)
+
+_SynchronizedStatement = Core.Name "hydra.java.syntax.SynchronizedStatement"
+
+_SynchronizedStatement_expression = Core.Name "expression"
+
+_SynchronizedStatement_block = Core.Name "block"
+
+data TryStatement =
+  TryStatementSimple TryStatement_Simple |
+  TryStatementWithFinally TryStatement_WithFinally |
+  TryStatementWithResources TryWithResourcesStatement
+  deriving (Eq, Ord, Read, Show)
+
+_TryStatement = Core.Name "hydra.java.syntax.TryStatement"
+
+_TryStatement_simple = Core.Name "simple"
+
+_TryStatement_withFinally = Core.Name "withFinally"
+
+_TryStatement_withResources = Core.Name "withResources"
+
+data TryStatement_Simple =
+  TryStatement_Simple {
+    tryStatement_SimpleBlock :: Block,
+    tryStatement_SimpleCatches :: Catches}
+  deriving (Eq, Ord, Read, Show)
+
+_TryStatement_Simple = Core.Name "hydra.java.syntax.TryStatement_Simple"
+
+_TryStatement_Simple_block = Core.Name "block"
+
+_TryStatement_Simple_catches = Core.Name "catches"
+
+data TryStatement_WithFinally =
+  TryStatement_WithFinally {
+    tryStatement_WithFinallyBlock :: Block,
+    tryStatement_WithFinallyCatches :: (Maybe Catches),
+    tryStatement_WithFinallyFinally :: Finally}
+  deriving (Eq, Ord, Read, Show)
+
+_TryStatement_WithFinally = Core.Name "hydra.java.syntax.TryStatement_WithFinally"
+
+_TryStatement_WithFinally_block = Core.Name "block"
+
+_TryStatement_WithFinally_catches = Core.Name "catches"
+
+_TryStatement_WithFinally_finally = Core.Name "finally"
+
+newtype Catches =
+  Catches {
+    unCatches :: [CatchClause]}
+  deriving (Eq, Ord, Read, Show)
+
+_Catches = Core.Name "hydra.java.syntax.Catches"
+
+data CatchClause =
+  CatchClause {
+    catchClauseParameter :: (Maybe CatchFormalParameter),
+    catchClauseBlock :: Block}
+  deriving (Eq, Ord, Read, Show)
+
+_CatchClause = Core.Name "hydra.java.syntax.CatchClause"
+
+_CatchClause_parameter = Core.Name "parameter"
+
+_CatchClause_block = Core.Name "block"
+
+data CatchFormalParameter =
+  CatchFormalParameter {
+    catchFormalParameterModifiers :: [VariableModifier],
+    catchFormalParameterType :: CatchType,
+    catchFormalParameterId :: VariableDeclaratorId}
+  deriving (Eq, Ord, Read, Show)
+
+_CatchFormalParameter = Core.Name "hydra.java.syntax.CatchFormalParameter"
+
+_CatchFormalParameter_modifiers = Core.Name "modifiers"
+
+_CatchFormalParameter_type = Core.Name "type"
+
+_CatchFormalParameter_id = Core.Name "id"
+
+data CatchType =
+  CatchType {
+    catchTypeType :: UnannClassType,
+    catchTypeTypes :: [ClassType]}
+  deriving (Eq, Ord, Read, Show)
+
+_CatchType = Core.Name "hydra.java.syntax.CatchType"
+
+_CatchType_type = Core.Name "type"
+
+_CatchType_types = Core.Name "types"
+
+newtype Finally =
+  Finally {
+    unFinally :: Block}
+  deriving (Eq, Ord, Read, Show)
+
+_Finally = Core.Name "hydra.java.syntax.Finally"
+
+data TryWithResourcesStatement =
+  TryWithResourcesStatement {
+    tryWithResourcesStatementResourceSpecification :: ResourceSpecification,
+    tryWithResourcesStatementBlock :: Block,
+    tryWithResourcesStatementCatches :: (Maybe Catches),
+    tryWithResourcesStatementFinally :: (Maybe Finally)}
+  deriving (Eq, Ord, Read, Show)
+
+_TryWithResourcesStatement = Core.Name "hydra.java.syntax.TryWithResourcesStatement"
+
+_TryWithResourcesStatement_resourceSpecification = Core.Name "resourceSpecification"
+
+_TryWithResourcesStatement_block = Core.Name "block"
+
+_TryWithResourcesStatement_catches = Core.Name "catches"
+
+_TryWithResourcesStatement_finally = Core.Name "finally"
+
+newtype ResourceSpecification =
+  ResourceSpecification {
+    unResourceSpecification :: [Resource]}
+  deriving (Eq, Ord, Read, Show)
+
+_ResourceSpecification = Core.Name "hydra.java.syntax.ResourceSpecification"
+
+data Resource =
+  ResourceLocal Resource_Local |
+  ResourceVariable VariableAccess
+  deriving (Eq, Ord, Read, Show)
+
+_Resource = Core.Name "hydra.java.syntax.Resource"
+
+_Resource_local = Core.Name "local"
+
+_Resource_variable = Core.Name "variable"
+
+data Resource_Local =
+  Resource_Local {
+    resource_LocalModifiers :: [VariableModifier],
+    resource_LocalType :: LocalVariableType,
+    resource_LocalIdentifier :: Identifier,
+    resource_LocalExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_Resource_Local = Core.Name "hydra.java.syntax.Resource_Local"
+
+_Resource_Local_modifiers = Core.Name "modifiers"
+
+_Resource_Local_type = Core.Name "type"
+
+_Resource_Local_identifier = Core.Name "identifier"
+
+_Resource_Local_expression = Core.Name "expression"
+
+data VariableAccess =
+  VariableAccessExpressionName ExpressionName |
+  VariableAccessFieldAccess FieldAccess
+  deriving (Eq, Ord, Read, Show)
+
+_VariableAccess = Core.Name "hydra.java.syntax.VariableAccess"
+
+_VariableAccess_expressionName = Core.Name "expressionName"
+
+_VariableAccess_fieldAccess = Core.Name "fieldAccess"
+
+data Primary =
+  PrimaryNoNewArray PrimaryNoNewArrayExpression |
+  PrimaryArrayCreation ArrayCreationExpression
+  deriving (Eq, Ord, Read, Show)
+
+_Primary = Core.Name "hydra.java.syntax.Primary"
+
+_Primary_noNewArray = Core.Name "noNewArray"
+
+_Primary_arrayCreation = Core.Name "arrayCreation"
+
+data PrimaryNoNewArrayExpression =
+  PrimaryNoNewArrayExpressionLiteral Literal |
+  PrimaryNoNewArrayExpressionClassLiteral ClassLiteral |
+  PrimaryNoNewArrayExpressionThis |
+  PrimaryNoNewArrayExpressionDotThis TypeName |
+  PrimaryNoNewArrayExpressionParens Expression |
+  PrimaryNoNewArrayExpressionClassInstance ClassInstanceCreationExpression |
+  PrimaryNoNewArrayExpressionFieldAccess FieldAccess |
+  PrimaryNoNewArrayExpressionArrayAccess ArrayAccess |
+  PrimaryNoNewArrayExpressionMethodInvocation MethodInvocation |
+  PrimaryNoNewArrayExpressionMethodReference MethodReference
+  deriving (Eq, Ord, Read, Show)
+
+_PrimaryNoNewArrayExpression = Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"
+
+_PrimaryNoNewArrayExpression_literal = Core.Name "literal"
+
+_PrimaryNoNewArrayExpression_classLiteral = Core.Name "classLiteral"
+
+_PrimaryNoNewArrayExpression_this = Core.Name "this"
+
+_PrimaryNoNewArrayExpression_dotThis = Core.Name "dotThis"
+
+_PrimaryNoNewArrayExpression_parens = Core.Name "parens"
+
+_PrimaryNoNewArrayExpression_classInstance = Core.Name "classInstance"
+
+_PrimaryNoNewArrayExpression_fieldAccess = Core.Name "fieldAccess"
+
+_PrimaryNoNewArrayExpression_arrayAccess = Core.Name "arrayAccess"
+
+_PrimaryNoNewArrayExpression_methodInvocation = Core.Name "methodInvocation"
+
+_PrimaryNoNewArrayExpression_methodReference = Core.Name "methodReference"
+
+data ClassLiteral =
+  ClassLiteralType TypeNameArray |
+  ClassLiteralNumericType NumericTypeArray |
+  ClassLiteralBoolean BooleanArray |
+  ClassLiteralVoid
+  deriving (Eq, Ord, Read, Show)
+
+_ClassLiteral = Core.Name "hydra.java.syntax.ClassLiteral"
+
+_ClassLiteral_type = Core.Name "type"
+
+_ClassLiteral_numericType = Core.Name "numericType"
+
+_ClassLiteral_boolean = Core.Name "boolean"
+
+_ClassLiteral_void = Core.Name "void"
+
+data TypeNameArray =
+  TypeNameArraySimple TypeName |
+  TypeNameArrayArray TypeNameArray
+  deriving (Eq, Ord, Read, Show)
+
+_TypeNameArray = Core.Name "hydra.java.syntax.TypeNameArray"
+
+_TypeNameArray_simple = Core.Name "simple"
+
+_TypeNameArray_array = Core.Name "array"
+
+data NumericTypeArray =
+  NumericTypeArraySimple NumericType |
+  NumericTypeArrayArray NumericTypeArray
+  deriving (Eq, Ord, Read, Show)
+
+_NumericTypeArray = Core.Name "hydra.java.syntax.NumericTypeArray"
+
+_NumericTypeArray_simple = Core.Name "simple"
+
+_NumericTypeArray_array = Core.Name "array"
+
+data BooleanArray =
+  BooleanArraySimple |
+  BooleanArrayArray BooleanArray
+  deriving (Eq, Ord, Read, Show)
+
+_BooleanArray = Core.Name "hydra.java.syntax.BooleanArray"
+
+_BooleanArray_simple = Core.Name "simple"
+
+_BooleanArray_array = Core.Name "array"
+
+data ClassInstanceCreationExpression =
+  ClassInstanceCreationExpression {
+    classInstanceCreationExpressionQualifier :: (Maybe ClassInstanceCreationExpression_Qualifier),
+    classInstanceCreationExpressionExpression :: UnqualifiedClassInstanceCreationExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_ClassInstanceCreationExpression = Core.Name "hydra.java.syntax.ClassInstanceCreationExpression"
+
+_ClassInstanceCreationExpression_qualifier = Core.Name "qualifier"
+
+_ClassInstanceCreationExpression_expression = Core.Name "expression"
+
+data ClassInstanceCreationExpression_Qualifier =
+  ClassInstanceCreationExpression_QualifierExpression ExpressionName |
+  ClassInstanceCreationExpression_QualifierPrimary Primary
+  deriving (Eq, Ord, Read, Show)
+
+_ClassInstanceCreationExpression_Qualifier = Core.Name "hydra.java.syntax.ClassInstanceCreationExpression_Qualifier"
+
+_ClassInstanceCreationExpression_Qualifier_expression = Core.Name "expression"
+
+_ClassInstanceCreationExpression_Qualifier_primary = Core.Name "primary"
+
+data UnqualifiedClassInstanceCreationExpression =
+  UnqualifiedClassInstanceCreationExpression {
+    unqualifiedClassInstanceCreationExpressionTypeArguments :: [TypeArgument],
+    unqualifiedClassInstanceCreationExpressionClassOrInterface :: ClassOrInterfaceTypeToInstantiate,
+    unqualifiedClassInstanceCreationExpressionArguments :: [Expression],
+    unqualifiedClassInstanceCreationExpressionBody :: (Maybe ClassBody)}
+  deriving (Eq, Ord, Read, Show)
+
+_UnqualifiedClassInstanceCreationExpression = Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"
+
+_UnqualifiedClassInstanceCreationExpression_typeArguments = Core.Name "typeArguments"
+
+_UnqualifiedClassInstanceCreationExpression_classOrInterface = Core.Name "classOrInterface"
+
+_UnqualifiedClassInstanceCreationExpression_arguments = Core.Name "arguments"
+
+_UnqualifiedClassInstanceCreationExpression_body = Core.Name "body"
+
+data ClassOrInterfaceTypeToInstantiate =
+  ClassOrInterfaceTypeToInstantiate {
+    classOrInterfaceTypeToInstantiateIdentifiers :: [AnnotatedIdentifier],
+    classOrInterfaceTypeToInstantiateTypeArguments :: (Maybe TypeArgumentsOrDiamond)}
+  deriving (Eq, Ord, Read, Show)
+
+_ClassOrInterfaceTypeToInstantiate = Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"
+
+_ClassOrInterfaceTypeToInstantiate_identifiers = Core.Name "identifiers"
+
+_ClassOrInterfaceTypeToInstantiate_typeArguments = Core.Name "typeArguments"
+
+data AnnotatedIdentifier =
+  AnnotatedIdentifier {
+    annotatedIdentifierAnnotations :: [Annotation],
+    annotatedIdentifierIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotatedIdentifier = Core.Name "hydra.java.syntax.AnnotatedIdentifier"
+
+_AnnotatedIdentifier_annotations = Core.Name "annotations"
+
+_AnnotatedIdentifier_identifier = Core.Name "identifier"
+
+data TypeArgumentsOrDiamond =
+  TypeArgumentsOrDiamondArguments [TypeArgument] |
+  TypeArgumentsOrDiamondDiamond
+  deriving (Eq, Ord, Read, Show)
+
+_TypeArgumentsOrDiamond = Core.Name "hydra.java.syntax.TypeArgumentsOrDiamond"
+
+_TypeArgumentsOrDiamond_arguments = Core.Name "arguments"
+
+_TypeArgumentsOrDiamond_diamond = Core.Name "diamond"
+
+data FieldAccess =
+  FieldAccess {
+    fieldAccessQualifier :: FieldAccess_Qualifier,
+    fieldAccessIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_FieldAccess = Core.Name "hydra.java.syntax.FieldAccess"
+
+_FieldAccess_qualifier = Core.Name "qualifier"
+
+_FieldAccess_identifier = Core.Name "identifier"
+
+data FieldAccess_Qualifier =
+  FieldAccess_QualifierPrimary Primary |
+  FieldAccess_QualifierSuper |
+  FieldAccess_QualifierTyped TypeName
+  deriving (Eq, Ord, Read, Show)
+
+_FieldAccess_Qualifier = Core.Name "hydra.java.syntax.FieldAccess_Qualifier"
+
+_FieldAccess_Qualifier_primary = Core.Name "primary"
+
+_FieldAccess_Qualifier_super = Core.Name "super"
+
+_FieldAccess_Qualifier_typed = Core.Name "typed"
+
+data ArrayAccess =
+  ArrayAccess {
+    arrayAccessExpression :: (Maybe Expression),
+    arrayAccessVariant :: ArrayAccess_Variant}
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayAccess = Core.Name "hydra.java.syntax.ArrayAccess"
+
+_ArrayAccess_expression = Core.Name "expression"
+
+_ArrayAccess_variant = Core.Name "variant"
+
+data ArrayAccess_Variant =
+  ArrayAccess_VariantName ExpressionName |
+  ArrayAccess_VariantPrimary PrimaryNoNewArrayExpression |
+  ArrayAccess_VariantArrayCreationWithInitializer ArrayCreationExpressionWithInitializer
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayAccess_Variant = Core.Name "hydra.java.syntax.ArrayAccess_Variant"
+
+_ArrayAccess_Variant_name = Core.Name "name"
+
+_ArrayAccess_Variant_primary = Core.Name "primary"
+
+_ArrayAccess_Variant_arrayCreationWithInitializer = Core.Name "arrayCreationWithInitializer"
+
+data MethodInvocation =
+  MethodInvocation {
+    methodInvocationHeader :: MethodInvocation_Header,
+    methodInvocationArguments :: [Expression]}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodInvocation = Core.Name "hydra.java.syntax.MethodInvocation"
+
+_MethodInvocation_header = Core.Name "header"
+
+_MethodInvocation_arguments = Core.Name "arguments"
+
+data MethodInvocation_Header =
+  MethodInvocation_HeaderSimple MethodName |
+  MethodInvocation_HeaderComplex MethodInvocation_Complex
+  deriving (Eq, Ord, Read, Show)
+
+_MethodInvocation_Header = Core.Name "hydra.java.syntax.MethodInvocation_Header"
+
+_MethodInvocation_Header_simple = Core.Name "simple"
+
+_MethodInvocation_Header_complex = Core.Name "complex"
+
+data MethodInvocation_Complex =
+  MethodInvocation_Complex {
+    methodInvocation_ComplexVariant :: MethodInvocation_Variant,
+    methodInvocation_ComplexTypeArguments :: [TypeArgument],
+    methodInvocation_ComplexIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodInvocation_Complex = Core.Name "hydra.java.syntax.MethodInvocation_Complex"
+
+_MethodInvocation_Complex_variant = Core.Name "variant"
+
+_MethodInvocation_Complex_typeArguments = Core.Name "typeArguments"
+
+_MethodInvocation_Complex_identifier = Core.Name "identifier"
+
+data MethodInvocation_Variant =
+  MethodInvocation_VariantType TypeName |
+  MethodInvocation_VariantExpression ExpressionName |
+  MethodInvocation_VariantPrimary Primary |
+  MethodInvocation_VariantSuper |
+  MethodInvocation_VariantTypeSuper TypeName
+  deriving (Eq, Ord, Read, Show)
+
+_MethodInvocation_Variant = Core.Name "hydra.java.syntax.MethodInvocation_Variant"
+
+_MethodInvocation_Variant_type = Core.Name "type"
+
+_MethodInvocation_Variant_expression = Core.Name "expression"
+
+_MethodInvocation_Variant_primary = Core.Name "primary"
+
+_MethodInvocation_Variant_super = Core.Name "super"
+
+_MethodInvocation_Variant_typeSuper = Core.Name "typeSuper"
+
+data MethodReference =
+  MethodReferenceExpression MethodReference_Expression |
+  MethodReferencePrimary MethodReference_Primary |
+  MethodReferenceReferenceType MethodReference_ReferenceType |
+  MethodReferenceSuper MethodReference_Super |
+  MethodReferenceNew MethodReference_New |
+  MethodReferenceArray MethodReference_Array
+  deriving (Eq, Ord, Read, Show)
+
+_MethodReference = Core.Name "hydra.java.syntax.MethodReference"
+
+_MethodReference_expression = Core.Name "expression"
+
+_MethodReference_primary = Core.Name "primary"
+
+_MethodReference_referenceType = Core.Name "referenceType"
+
+_MethodReference_super = Core.Name "super"
+
+_MethodReference_new = Core.Name "new"
+
+_MethodReference_array = Core.Name "array"
+
+data MethodReference_Expression =
+  MethodReference_Expression {
+    methodReference_ExpressionName :: ExpressionName,
+    methodReference_ExpressionTypeArguments :: [TypeArgument],
+    methodReference_ExpressionIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodReference_Expression = Core.Name "hydra.java.syntax.MethodReference_Expression"
+
+_MethodReference_Expression_name = Core.Name "name"
+
+_MethodReference_Expression_typeArguments = Core.Name "typeArguments"
+
+_MethodReference_Expression_identifier = Core.Name "identifier"
+
+data MethodReference_Primary =
+  MethodReference_Primary {
+    methodReference_PrimaryPrimary :: Primary,
+    methodReference_PrimaryTypeArguments :: [TypeArgument],
+    methodReference_PrimaryIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodReference_Primary = Core.Name "hydra.java.syntax.MethodReference_Primary"
+
+_MethodReference_Primary_primary = Core.Name "primary"
+
+_MethodReference_Primary_typeArguments = Core.Name "typeArguments"
+
+_MethodReference_Primary_identifier = Core.Name "identifier"
+
+data MethodReference_ReferenceType =
+  MethodReference_ReferenceType {
+    methodReference_ReferenceTypeReferenceType :: ReferenceType,
+    methodReference_ReferenceTypeTypeArguments :: [TypeArgument],
+    methodReference_ReferenceTypeIdentifier :: Identifier}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodReference_ReferenceType = Core.Name "hydra.java.syntax.MethodReference_ReferenceType"
+
+_MethodReference_ReferenceType_referenceType = Core.Name "referenceType"
+
+_MethodReference_ReferenceType_typeArguments = Core.Name "typeArguments"
+
+_MethodReference_ReferenceType_identifier = Core.Name "identifier"
+
+data MethodReference_Super =
+  MethodReference_Super {
+    methodReference_SuperTypeArguments :: [TypeArgument],
+    methodReference_SuperIdentifier :: Identifier,
+    methodReference_SuperSuper :: Bool}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodReference_Super = Core.Name "hydra.java.syntax.MethodReference_Super"
+
+_MethodReference_Super_typeArguments = Core.Name "typeArguments"
+
+_MethodReference_Super_identifier = Core.Name "identifier"
+
+_MethodReference_Super_super = Core.Name "super"
+
+data MethodReference_New =
+  MethodReference_New {
+    methodReference_NewClassType :: ClassType,
+    methodReference_NewTypeArguments :: [TypeArgument]}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodReference_New = Core.Name "hydra.java.syntax.MethodReference_New"
+
+_MethodReference_New_classType = Core.Name "classType"
+
+_MethodReference_New_typeArguments = Core.Name "typeArguments"
+
+newtype MethodReference_Array =
+  MethodReference_Array {
+    unMethodReference_Array :: ArrayType}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodReference_Array = Core.Name "hydra.java.syntax.MethodReference_Array"
+
+data ArrayCreationExpression =
+  ArrayCreationExpressionWithoutInitializer_ ArrayCreationExpressionWithoutInitializer |
+  ArrayCreationExpressionWithInitializer_ ArrayCreationExpressionWithInitializer
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayCreationExpression = Core.Name "hydra.java.syntax.ArrayCreationExpression"
+
+_ArrayCreationExpression_withoutInitializer = Core.Name "withoutInitializer"
+
+_ArrayCreationExpression_withInitializer = Core.Name "withInitializer"
+
+data ArrayCreationExpressionWithoutInitializer =
+  ArrayCreationExpressionWithoutInitializerPrimitive ArrayCreationExpressionWithoutInitializer_Primitive |
+  ArrayCreationExpressionWithoutInitializerClassOrInterface ArrayCreationExpressionWithoutInitializer_ClassOrInterface
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayCreationExpressionWithoutInitializer = Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer"
+
+_ArrayCreationExpressionWithoutInitializer_primitive = Core.Name "primitive"
+
+_ArrayCreationExpressionWithoutInitializer_classOrInterface = Core.Name "classOrInterface"
+
+data ArrayCreationExpressionWithoutInitializer_Primitive =
+  ArrayCreationExpressionWithoutInitializer_Primitive {
+    arrayCreationExpressionWithoutInitializer_PrimitiveType :: PrimitiveTypeWithAnnotations,
+    arrayCreationExpressionWithoutInitializer_PrimitiveDimExprs :: [DimExpr],
+    arrayCreationExpressionWithoutInitializer_PrimitiveDims :: (Maybe Dims)}
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayCreationExpressionWithoutInitializer_Primitive =
+    Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"
+
+_ArrayCreationExpressionWithoutInitializer_Primitive_type = Core.Name "type"
+
+_ArrayCreationExpressionWithoutInitializer_Primitive_dimExprs = Core.Name "dimExprs"
+
+_ArrayCreationExpressionWithoutInitializer_Primitive_dims = Core.Name "dims"
+
+data ArrayCreationExpressionWithoutInitializer_ClassOrInterface =
+  ArrayCreationExpressionWithoutInitializer_ClassOrInterface {
+    arrayCreationExpressionWithoutInitializer_ClassOrInterfaceType :: ClassOrInterfaceType,
+    arrayCreationExpressionWithoutInitializer_ClassOrInterfaceDimExprs :: [DimExpr],
+    arrayCreationExpressionWithoutInitializer_ClassOrInterfaceDims :: (Maybe Dims)}
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayCreationExpressionWithoutInitializer_ClassOrInterface =
+    Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"
+
+_ArrayCreationExpressionWithoutInitializer_ClassOrInterface_type = Core.Name "type"
+
+_ArrayCreationExpressionWithoutInitializer_ClassOrInterface_dimExprs = Core.Name "dimExprs"
+
+_ArrayCreationExpressionWithoutInitializer_ClassOrInterface_dims = Core.Name "dims"
+
+data ArrayCreationExpressionWithInitializer =
+  ArrayCreationExpressionWithInitializerPrimitive ArrayCreationExpressionWithInitializer_Primitive |
+  ArrayCreationExpressionWithInitializerClassOrInterface ArrayCreationExpressionWithInitializer_ClassOrInterface
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayCreationExpressionWithInitializer = Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer"
+
+_ArrayCreationExpressionWithInitializer_primitive = Core.Name "primitive"
+
+_ArrayCreationExpressionWithInitializer_classOrInterface = Core.Name "classOrInterface"
+
+data ArrayCreationExpressionWithInitializer_Primitive =
+  ArrayCreationExpressionWithInitializer_Primitive {
+    arrayCreationExpressionWithInitializer_PrimitiveType :: PrimitiveTypeWithAnnotations,
+    arrayCreationExpressionWithInitializer_PrimitiveDims :: [Dims],
+    arrayCreationExpressionWithInitializer_PrimitiveArray :: ArrayInitializer}
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayCreationExpressionWithInitializer_Primitive =
+    Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"
+
+_ArrayCreationExpressionWithInitializer_Primitive_type = Core.Name "type"
+
+_ArrayCreationExpressionWithInitializer_Primitive_dims = Core.Name "dims"
+
+_ArrayCreationExpressionWithInitializer_Primitive_array = Core.Name "array"
+
+data ArrayCreationExpressionWithInitializer_ClassOrInterface =
+  ArrayCreationExpressionWithInitializer_ClassOrInterface {
+    arrayCreationExpressionWithInitializer_ClassOrInterfaceType :: ClassOrInterfaceType,
+    arrayCreationExpressionWithInitializer_ClassOrInterfaceDims :: [Dims],
+    arrayCreationExpressionWithInitializer_ClassOrInterfaceArray :: ArrayInitializer}
+  deriving (Eq, Ord, Read, Show)
+
+_ArrayCreationExpressionWithInitializer_ClassOrInterface =
+    Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"
+
+_ArrayCreationExpressionWithInitializer_ClassOrInterface_type = Core.Name "type"
+
+_ArrayCreationExpressionWithInitializer_ClassOrInterface_dims = Core.Name "dims"
+
+_ArrayCreationExpressionWithInitializer_ClassOrInterface_array = Core.Name "array"
+
+data DimExpr =
+  DimExpr {
+    dimExprAnnotations :: [Annotation],
+    dimExprExpression :: (Maybe Expression)}
+  deriving (Eq, Ord, Read, Show)
+
+_DimExpr = Core.Name "hydra.java.syntax.DimExpr"
+
+_DimExpr_annotations = Core.Name "annotations"
+
+_DimExpr_expression = Core.Name "expression"
+
+data Expression =
+  ExpressionLambda LambdaExpression |
+  ExpressionAssignment AssignmentExpression
+  deriving (Eq, Ord, Read, Show)
+
+_Expression = Core.Name "hydra.java.syntax.Expression"
+
+_Expression_lambda = Core.Name "lambda"
+
+_Expression_assignment = Core.Name "assignment"
+
+data LambdaExpression =
+  LambdaExpression {
+    lambdaExpressionParameters :: LambdaParameters,
+    lambdaExpressionBody :: LambdaBody}
+  deriving (Eq, Ord, Read, Show)
+
+_LambdaExpression = Core.Name "hydra.java.syntax.LambdaExpression"
+
+_LambdaExpression_parameters = Core.Name "parameters"
+
+_LambdaExpression_body = Core.Name "body"
+
+data LambdaParameters =
+  LambdaParametersTuple [LambdaParameters] |
+  LambdaParametersSingle Identifier
+  deriving (Eq, Ord, Read, Show)
+
+_LambdaParameters = Core.Name "hydra.java.syntax.LambdaParameters"
+
+_LambdaParameters_tuple = Core.Name "tuple"
+
+_LambdaParameters_single = Core.Name "single"
+
+data LambdaParameter =
+  LambdaParameterNormal LambdaParameter_Normal |
+  LambdaParameterVariableArity VariableArityParameter
+  deriving (Eq, Ord, Read, Show)
+
+_LambdaParameter = Core.Name "hydra.java.syntax.LambdaParameter"
+
+_LambdaParameter_normal = Core.Name "normal"
+
+_LambdaParameter_variableArity = Core.Name "variableArity"
+
+data LambdaParameter_Normal =
+  LambdaParameter_Normal {
+    lambdaParameter_NormalModifiers :: [VariableModifier],
+    lambdaParameter_NormalType :: LambdaParameterType,
+    lambdaParameter_NormalId :: VariableDeclaratorId}
+  deriving (Eq, Ord, Read, Show)
+
+_LambdaParameter_Normal = Core.Name "hydra.java.syntax.LambdaParameter_Normal"
+
+_LambdaParameter_Normal_modifiers = Core.Name "modifiers"
+
+_LambdaParameter_Normal_type = Core.Name "type"
+
+_LambdaParameter_Normal_id = Core.Name "id"
+
+data LambdaParameterType =
+  LambdaParameterTypeType UnannType |
+  LambdaParameterTypeVar
+  deriving (Eq, Ord, Read, Show)
+
+_LambdaParameterType = Core.Name "hydra.java.syntax.LambdaParameterType"
+
+_LambdaParameterType_type = Core.Name "type"
+
+_LambdaParameterType_var = Core.Name "var"
+
+data LambdaBody =
+  LambdaBodyExpression Expression |
+  LambdaBodyBlock Block
+  deriving (Eq, Ord, Read, Show)
+
+_LambdaBody = Core.Name "hydra.java.syntax.LambdaBody"
+
+_LambdaBody_expression = Core.Name "expression"
+
+_LambdaBody_block = Core.Name "block"
+
+data AssignmentExpression =
+  AssignmentExpressionConditional ConditionalExpression |
+  AssignmentExpressionAssignment Assignment
+  deriving (Eq, Ord, Read, Show)
+
+_AssignmentExpression = Core.Name "hydra.java.syntax.AssignmentExpression"
+
+_AssignmentExpression_conditional = Core.Name "conditional"
+
+_AssignmentExpression_assignment = Core.Name "assignment"
+
+data Assignment =
+  Assignment {
+    assignmentLhs :: LeftHandSide,
+    assignmentOp :: AssignmentOperator,
+    assignmentExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_Assignment = Core.Name "hydra.java.syntax.Assignment"
+
+_Assignment_lhs = Core.Name "lhs"
+
+_Assignment_op = Core.Name "op"
+
+_Assignment_expression = Core.Name "expression"
+
+data LeftHandSide =
+  LeftHandSideExpressionName ExpressionName |
+  LeftHandSideFieldAccess FieldAccess |
+  LeftHandSideArrayAccess ArrayAccess
+  deriving (Eq, Ord, Read, Show)
+
+_LeftHandSide = Core.Name "hydra.java.syntax.LeftHandSide"
+
+_LeftHandSide_expressionName = Core.Name "expressionName"
+
+_LeftHandSide_fieldAccess = Core.Name "fieldAccess"
+
+_LeftHandSide_arrayAccess = Core.Name "arrayAccess"
+
+data AssignmentOperator =
+  AssignmentOperatorSimple |
+  AssignmentOperatorTimes |
+  AssignmentOperatorDiv |
+  AssignmentOperatorMod |
+  AssignmentOperatorPlus |
+  AssignmentOperatorMinus |
+  AssignmentOperatorShiftLeft |
+  AssignmentOperatorShiftRight |
+  AssignmentOperatorShiftRightZeroFill |
+  AssignmentOperatorAnd |
+  AssignmentOperatorXor |
+  AssignmentOperatorOr
+  deriving (Eq, Ord, Read, Show)
+
+_AssignmentOperator = Core.Name "hydra.java.syntax.AssignmentOperator"
+
+_AssignmentOperator_simple = Core.Name "simple"
+
+_AssignmentOperator_times = Core.Name "times"
+
+_AssignmentOperator_div = Core.Name "div"
+
+_AssignmentOperator_mod = Core.Name "mod"
+
+_AssignmentOperator_plus = Core.Name "plus"
+
+_AssignmentOperator_minus = Core.Name "minus"
+
+_AssignmentOperator_shiftLeft = Core.Name "shiftLeft"
+
+_AssignmentOperator_shiftRight = Core.Name "shiftRight"
+
+_AssignmentOperator_shiftRightZeroFill = Core.Name "shiftRightZeroFill"
+
+_AssignmentOperator_and = Core.Name "and"
+
+_AssignmentOperator_xor = Core.Name "xor"
+
+_AssignmentOperator_or = Core.Name "or"
+
+data ConditionalExpression =
+  ConditionalExpressionSimple ConditionalOrExpression |
+  ConditionalExpressionTernaryCond ConditionalExpression_TernaryCond |
+  ConditionalExpressionTernaryLambda ConditionalExpression_TernaryLambda
+  deriving (Eq, Ord, Read, Show)
+
+_ConditionalExpression = Core.Name "hydra.java.syntax.ConditionalExpression"
+
+_ConditionalExpression_simple = Core.Name "simple"
+
+_ConditionalExpression_ternaryCond = Core.Name "ternaryCond"
+
+_ConditionalExpression_ternaryLambda = Core.Name "ternaryLambda"
+
+data ConditionalExpression_TernaryCond =
+  ConditionalExpression_TernaryCond {
+    conditionalExpression_TernaryCondCond :: ConditionalOrExpression,
+    conditionalExpression_TernaryCondIfTrue :: Expression,
+    conditionalExpression_TernaryCondIfFalse :: ConditionalExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_ConditionalExpression_TernaryCond = Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"
+
+_ConditionalExpression_TernaryCond_cond = Core.Name "cond"
+
+_ConditionalExpression_TernaryCond_ifTrue = Core.Name "ifTrue"
+
+_ConditionalExpression_TernaryCond_ifFalse = Core.Name "ifFalse"
+
+data ConditionalExpression_TernaryLambda =
+  ConditionalExpression_TernaryLambda {
+    conditionalExpression_TernaryLambdaCond :: ConditionalOrExpression,
+    conditionalExpression_TernaryLambdaIfTrue :: Expression,
+    conditionalExpression_TernaryLambdaIfFalse :: LambdaExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_ConditionalExpression_TernaryLambda = Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"
+
+_ConditionalExpression_TernaryLambda_cond = Core.Name "cond"
+
+_ConditionalExpression_TernaryLambda_ifTrue = Core.Name "ifTrue"
+
+_ConditionalExpression_TernaryLambda_ifFalse = Core.Name "ifFalse"
+
+newtype ConditionalOrExpression =
+  ConditionalOrExpression {
+    unConditionalOrExpression :: [ConditionalAndExpression]}
+  deriving (Eq, Ord, Read, Show)
+
+_ConditionalOrExpression = Core.Name "hydra.java.syntax.ConditionalOrExpression"
+
+newtype ConditionalAndExpression =
+  ConditionalAndExpression {
+    unConditionalAndExpression :: [InclusiveOrExpression]}
+  deriving (Eq, Ord, Read, Show)
+
+_ConditionalAndExpression = Core.Name "hydra.java.syntax.ConditionalAndExpression"
+
+newtype InclusiveOrExpression =
+  InclusiveOrExpression {
+    unInclusiveOrExpression :: [ExclusiveOrExpression]}
+  deriving (Eq, Ord, Read, Show)
+
+_InclusiveOrExpression = Core.Name "hydra.java.syntax.InclusiveOrExpression"
+
+newtype ExclusiveOrExpression =
+  ExclusiveOrExpression {
+    unExclusiveOrExpression :: [AndExpression]}
+  deriving (Eq, Ord, Read, Show)
+
+_ExclusiveOrExpression = Core.Name "hydra.java.syntax.ExclusiveOrExpression"
+
+newtype AndExpression =
+  AndExpression {
+    unAndExpression :: [EqualityExpression]}
+  deriving (Eq, Ord, Read, Show)
+
+_AndExpression = Core.Name "hydra.java.syntax.AndExpression"
+
+data EqualityExpression =
+  EqualityExpressionUnary RelationalExpression |
+  EqualityExpressionEqual EqualityExpression_Binary |
+  EqualityExpressionNotEqual EqualityExpression_Binary
+  deriving (Eq, Ord, Read, Show)
+
+_EqualityExpression = Core.Name "hydra.java.syntax.EqualityExpression"
+
+_EqualityExpression_unary = Core.Name "unary"
+
+_EqualityExpression_equal = Core.Name "equal"
+
+_EqualityExpression_notEqual = Core.Name "notEqual"
+
+data EqualityExpression_Binary =
+  EqualityExpression_Binary {
+    equalityExpression_BinaryLhs :: EqualityExpression,
+    equalityExpression_BinaryRhs :: RelationalExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_EqualityExpression_Binary = Core.Name "hydra.java.syntax.EqualityExpression_Binary"
+
+_EqualityExpression_Binary_lhs = Core.Name "lhs"
+
+_EqualityExpression_Binary_rhs = Core.Name "rhs"
+
+data RelationalExpression =
+  RelationalExpressionSimple ShiftExpression |
+  RelationalExpressionLessThan RelationalExpression_LessThan |
+  RelationalExpressionGreaterThan RelationalExpression_GreaterThan |
+  RelationalExpressionLessThanEqual RelationalExpression_LessThanEqual |
+  RelationalExpressionGreaterThanEqual RelationalExpression_GreaterThanEqual |
+  RelationalExpressionInstanceofExpression InstanceofExpression
+  deriving (Eq, Ord, Read, Show)
+
+_RelationalExpression = Core.Name "hydra.java.syntax.RelationalExpression"
+
+_RelationalExpression_simple = Core.Name "simple"
+
+_RelationalExpression_lessThan = Core.Name "lessThan"
+
+_RelationalExpression_greaterThan = Core.Name "greaterThan"
+
+_RelationalExpression_lessThanEqual = Core.Name "lessThanEqual"
+
+_RelationalExpression_greaterThanEqual = Core.Name "greaterThanEqual"
+
+_RelationalExpression_instanceofExpression = Core.Name "instanceofExpression"
+
+data RelationalExpression_LessThan =
+  RelationalExpression_LessThan {
+    relationalExpression_LessThanLhs :: RelationalExpression,
+    relationalExpression_LessThanRhs :: ShiftExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_RelationalExpression_LessThan = Core.Name "hydra.java.syntax.RelationalExpression_LessThan"
+
+_RelationalExpression_LessThan_lhs = Core.Name "lhs"
+
+_RelationalExpression_LessThan_rhs = Core.Name "rhs"
+
+data RelationalExpression_GreaterThan =
+  RelationalExpression_GreaterThan {
+    relationalExpression_GreaterThanLhs :: RelationalExpression,
+    relationalExpression_GreaterThanRhs :: ShiftExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_RelationalExpression_GreaterThan = Core.Name "hydra.java.syntax.RelationalExpression_GreaterThan"
+
+_RelationalExpression_GreaterThan_lhs = Core.Name "lhs"
+
+_RelationalExpression_GreaterThan_rhs = Core.Name "rhs"
+
+data RelationalExpression_LessThanEqual =
+  RelationalExpression_LessThanEqual {
+    relationalExpression_LessThanEqualLhs :: RelationalExpression,
+    relationalExpression_LessThanEqualRhs :: ShiftExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_RelationalExpression_LessThanEqual = Core.Name "hydra.java.syntax.RelationalExpression_LessThanEqual"
+
+_RelationalExpression_LessThanEqual_lhs = Core.Name "lhs"
+
+_RelationalExpression_LessThanEqual_rhs = Core.Name "rhs"
+
+data RelationalExpression_GreaterThanEqual =
+  RelationalExpression_GreaterThanEqual {
+    relationalExpression_GreaterThanEqualLhs :: RelationalExpression,
+    relationalExpression_GreaterThanEqualRhs :: ShiftExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_RelationalExpression_GreaterThanEqual = Core.Name "hydra.java.syntax.RelationalExpression_GreaterThanEqual"
+
+_RelationalExpression_GreaterThanEqual_lhs = Core.Name "lhs"
+
+_RelationalExpression_GreaterThanEqual_rhs = Core.Name "rhs"
+
+data InstanceofExpression =
+  InstanceofExpression {
+    instanceofExpressionLhs :: RelationalExpression,
+    instanceofExpressionRhs :: InstanceofExpression_Rhs}
+  deriving (Eq, Ord, Read, Show)
+
+_InstanceofExpression = Core.Name "hydra.java.syntax.InstanceofExpression"
+
+_InstanceofExpression_lhs = Core.Name "lhs"
+
+_InstanceofExpression_rhs = Core.Name "rhs"
+
+data InstanceofExpression_Rhs =
+  InstanceofExpression_RhsReferenceType ReferenceType |
+  InstanceofExpression_RhsPattern Pattern
+  deriving (Eq, Ord, Read, Show)
+
+_InstanceofExpression_Rhs = Core.Name "hydra.java.syntax.InstanceofExpression_Rhs"
+
+_InstanceofExpression_Rhs_referenceType = Core.Name "referenceType"
+
+_InstanceofExpression_Rhs_pattern = Core.Name "pattern"
+
+data ShiftExpression =
+  ShiftExpressionUnary AdditiveExpression |
+  ShiftExpressionShiftLeft ShiftExpression_Binary |
+  ShiftExpressionShiftRight ShiftExpression_Binary |
+  ShiftExpressionShiftRightZeroFill ShiftExpression_Binary
+  deriving (Eq, Ord, Read, Show)
+
+_ShiftExpression = Core.Name "hydra.java.syntax.ShiftExpression"
+
+_ShiftExpression_unary = Core.Name "unary"
+
+_ShiftExpression_shiftLeft = Core.Name "shiftLeft"
+
+_ShiftExpression_shiftRight = Core.Name "shiftRight"
+
+_ShiftExpression_shiftRightZeroFill = Core.Name "shiftRightZeroFill"
+
+data ShiftExpression_Binary =
+  ShiftExpression_Binary {
+    shiftExpression_BinaryLhs :: ShiftExpression,
+    shiftExpression_BinaryRhs :: AdditiveExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_ShiftExpression_Binary = Core.Name "hydra.java.syntax.ShiftExpression_Binary"
+
+_ShiftExpression_Binary_lhs = Core.Name "lhs"
+
+_ShiftExpression_Binary_rhs = Core.Name "rhs"
+
+data AdditiveExpression =
+  AdditiveExpressionUnary MultiplicativeExpression |
+  AdditiveExpressionPlus AdditiveExpression_Binary |
+  AdditiveExpressionMinus AdditiveExpression_Binary
+  deriving (Eq, Ord, Read, Show)
+
+_AdditiveExpression = Core.Name "hydra.java.syntax.AdditiveExpression"
+
+_AdditiveExpression_unary = Core.Name "unary"
+
+_AdditiveExpression_plus = Core.Name "plus"
+
+_AdditiveExpression_minus = Core.Name "minus"
+
+data AdditiveExpression_Binary =
+  AdditiveExpression_Binary {
+    additiveExpression_BinaryLhs :: AdditiveExpression,
+    additiveExpression_BinaryRhs :: MultiplicativeExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_AdditiveExpression_Binary = Core.Name "hydra.java.syntax.AdditiveExpression_Binary"
+
+_AdditiveExpression_Binary_lhs = Core.Name "lhs"
+
+_AdditiveExpression_Binary_rhs = Core.Name "rhs"
+
+data MultiplicativeExpression =
+  MultiplicativeExpressionUnary UnaryExpression |
+  MultiplicativeExpressionTimes MultiplicativeExpression_Binary |
+  MultiplicativeExpressionDivide MultiplicativeExpression_Binary |
+  MultiplicativeExpressionMod MultiplicativeExpression_Binary
+  deriving (Eq, Ord, Read, Show)
+
+_MultiplicativeExpression = Core.Name "hydra.java.syntax.MultiplicativeExpression"
+
+_MultiplicativeExpression_unary = Core.Name "unary"
+
+_MultiplicativeExpression_times = Core.Name "times"
+
+_MultiplicativeExpression_divide = Core.Name "divide"
+
+_MultiplicativeExpression_mod = Core.Name "mod"
+
+data MultiplicativeExpression_Binary =
+  MultiplicativeExpression_Binary {
+    multiplicativeExpression_BinaryLhs :: MultiplicativeExpression,
+    multiplicativeExpression_BinaryRhs :: UnaryExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_MultiplicativeExpression_Binary = Core.Name "hydra.java.syntax.MultiplicativeExpression_Binary"
+
+_MultiplicativeExpression_Binary_lhs = Core.Name "lhs"
+
+_MultiplicativeExpression_Binary_rhs = Core.Name "rhs"
+
+data UnaryExpression =
+  UnaryExpressionPreIncrement PreIncrementExpression |
+  UnaryExpressionPreDecrement PreDecrementExpression |
+  UnaryExpressionPlus UnaryExpression |
+  UnaryExpressionMinus UnaryExpression |
+  UnaryExpressionOther UnaryExpressionNotPlusMinus
+  deriving (Eq, Ord, Read, Show)
+
+_UnaryExpression = Core.Name "hydra.java.syntax.UnaryExpression"
+
+_UnaryExpression_preIncrement = Core.Name "preIncrement"
+
+_UnaryExpression_preDecrement = Core.Name "preDecrement"
+
+_UnaryExpression_plus = Core.Name "plus"
+
+_UnaryExpression_minus = Core.Name "minus"
+
+_UnaryExpression_other = Core.Name "other"
+
+newtype PreIncrementExpression =
+  PreIncrementExpression {
+    unPreIncrementExpression :: UnaryExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_PreIncrementExpression = Core.Name "hydra.java.syntax.PreIncrementExpression"
+
+newtype PreDecrementExpression =
+  PreDecrementExpression {
+    unPreDecrementExpression :: UnaryExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_PreDecrementExpression = Core.Name "hydra.java.syntax.PreDecrementExpression"
+
+data UnaryExpressionNotPlusMinus =
+  UnaryExpressionNotPlusMinusPostfix PostfixExpression |
+  UnaryExpressionNotPlusMinusTilde UnaryExpression |
+  UnaryExpressionNotPlusMinusNot UnaryExpression |
+  UnaryExpressionNotPlusMinusCast CastExpression |
+  UnaryExpressionNotPlusMinusSwitchExpression SwitchExpression
+  deriving (Eq, Ord, Read, Show)
+
+_UnaryExpressionNotPlusMinus = Core.Name "hydra.java.syntax.UnaryExpressionNotPlusMinus"
+
+_UnaryExpressionNotPlusMinus_postfix = Core.Name "postfix"
+
+_UnaryExpressionNotPlusMinus_tilde = Core.Name "tilde"
+
+_UnaryExpressionNotPlusMinus_not = Core.Name "not"
+
+_UnaryExpressionNotPlusMinus_cast = Core.Name "cast"
+
+_UnaryExpressionNotPlusMinus_switchExpression = Core.Name "switchExpression"
+
+data PostfixExpression =
+  PostfixExpressionPrimary Primary |
+  PostfixExpressionName ExpressionName |
+  PostfixExpressionPostIncrement PostIncrementExpression |
+  PostfixExpressionPostDecrement PostDecrementExpression
+  deriving (Eq, Ord, Read, Show)
+
+_PostfixExpression = Core.Name "hydra.java.syntax.PostfixExpression"
+
+_PostfixExpression_primary = Core.Name "primary"
+
+_PostfixExpression_name = Core.Name "name"
+
+_PostfixExpression_postIncrement = Core.Name "postIncrement"
+
+_PostfixExpression_postDecrement = Core.Name "postDecrement"
+
+newtype PostIncrementExpression =
+  PostIncrementExpression {
+    unPostIncrementExpression :: PostfixExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_PostIncrementExpression = Core.Name "hydra.java.syntax.PostIncrementExpression"
+
+newtype PostDecrementExpression =
+  PostDecrementExpression {
+    unPostDecrementExpression :: PostfixExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_PostDecrementExpression = Core.Name "hydra.java.syntax.PostDecrementExpression"
+
+data CastExpression =
+  CastExpressionPrimitive CastExpression_Primitive |
+  CastExpressionNotPlusMinus CastExpression_NotPlusMinus |
+  CastExpressionLambda CastExpression_Lambda
+  deriving (Eq, Ord, Read, Show)
+
+_CastExpression = Core.Name "hydra.java.syntax.CastExpression"
+
+_CastExpression_primitive = Core.Name "primitive"
+
+_CastExpression_notPlusMinus = Core.Name "notPlusMinus"
+
+_CastExpression_lambda = Core.Name "lambda"
+
+data CastExpression_Primitive =
+  CastExpression_Primitive {
+    castExpression_PrimitiveType :: PrimitiveTypeWithAnnotations,
+    castExpression_PrimitiveExpression :: UnaryExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_CastExpression_Primitive = Core.Name "hydra.java.syntax.CastExpression_Primitive"
+
+_CastExpression_Primitive_type = Core.Name "type"
+
+_CastExpression_Primitive_expression = Core.Name "expression"
+
+data CastExpression_NotPlusMinus =
+  CastExpression_NotPlusMinus {
+    castExpression_NotPlusMinusRefAndBounds :: CastExpression_RefAndBounds,
+    castExpression_NotPlusMinusExpression :: UnaryExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_CastExpression_NotPlusMinus = Core.Name "hydra.java.syntax.CastExpression_NotPlusMinus"
+
+_CastExpression_NotPlusMinus_refAndBounds = Core.Name "refAndBounds"
+
+_CastExpression_NotPlusMinus_expression = Core.Name "expression"
+
+data CastExpression_Lambda =
+  CastExpression_Lambda {
+    castExpression_LambdaRefAndBounds :: CastExpression_RefAndBounds,
+    castExpression_LambdaExpression :: LambdaExpression}
+  deriving (Eq, Ord, Read, Show)
+
+_CastExpression_Lambda = Core.Name "hydra.java.syntax.CastExpression_Lambda"
+
+_CastExpression_Lambda_refAndBounds = Core.Name "refAndBounds"
+
+_CastExpression_Lambda_expression = Core.Name "expression"
+
+data CastExpression_RefAndBounds =
+  CastExpression_RefAndBounds {
+    castExpression_RefAndBoundsType :: ReferenceType,
+    castExpression_RefAndBoundsBounds :: [AdditionalBound]}
+  deriving (Eq, Ord, Read, Show)
+
+_CastExpression_RefAndBounds = Core.Name "hydra.java.syntax.CastExpression_RefAndBounds"
+
+_CastExpression_RefAndBounds_type = Core.Name "type"
+
+_CastExpression_RefAndBounds_bounds = Core.Name "bounds"
+
+data SwitchExpression =
+  SwitchExpression {
+    switchExpressionCond :: Expression,
+    switchExpressionBlock :: SwitchBlock}
+  deriving (Eq, Ord, Read, Show)
+
+_SwitchExpression = Core.Name "hydra.java.syntax.SwitchExpression"
+
+_SwitchExpression_cond = Core.Name "cond"
+
+_SwitchExpression_block = Core.Name "block"
+
+newtype ConstantExpression =
+  ConstantExpression {
+    unConstantExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_ConstantExpression = Core.Name "hydra.java.syntax.ConstantExpression"
diff --git a/src/main/haskell/Hydra/Java/Testing.hs b/src/main/haskell/Hydra/Java/Testing.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Java/Testing.hs
@@ -0,0 +1,171 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Java test code generation codec for JUnit-based generation tests
+
+module Hydra.Java.Testing where
+
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Classes as Classes
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Constants as Constants
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Java.Syntax as Syntax
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers
+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Names as Names
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Serialization as Serialization
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Test.Utils as Utils
+import qualified Hydra.Testing as Testing
+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
+
+-- | Build the complete Java test module content
+buildJavaTestModule :: Packaging.Module -> Testing.TestGroup -> String -> String
+buildJavaTestModule testModule testGroup testBody =
+
+      let ns_ = Packaging.moduleName testModule
+          parts = Strings.splitOn "." (Packaging.unModuleName ns_)
+          packageName = Strings.intercalate "." (Optionals.fromOptional [] (Lists.maybeInit parts))
+          className_ = Strings.cat2 (Formatting.capitalize (Optionals.fromOptional "" (Lists.maybeLast parts))) "Test"
+          groupName_ = Testing.testGroupName testGroup
+          standardImports =
+                  [
+                    "import org.junit.jupiter.api.Test;",
+                    "import static org.junit.jupiter.api.Assertions.*;",
+                    "import java.util.*;",
+                    "import hydra.overlay.java.util.*;"]
+          header =
+                  Strings.cat [
+                    Strings.cat2 "// " Constants.warningAutoGeneratedFile,
+                    "\n",
+                    (Strings.cat2 "// " groupName_),
+                    "\n\n",
+                    (Strings.cat [
+                      "package ",
+                      packageName,
+                      ";\n\n"]),
+                    (Strings.intercalate "\n" standardImports),
+                    "\n\n",
+                    (Strings.cat [
+                      "public class ",
+                      className_,
+                      " {\n\n"])]
+      in (Strings.cat [
+        header,
+        testBody,
+        "\n}\n"])
+
+-- | Standard imports for Java JUnit test files
+findJavaImports :: [String]
+findJavaImports =
+    [
+      "import org.junit.jupiter.api.Test;",
+      "import static org.junit.jupiter.api.Assertions.*;",
+      "import java.util.*;"]
+
+-- | Format a test name for Java (PascalCase method name with 'test' prefix)
+formatJavaTestName :: String -> String
+formatJavaTestName name =
+
+      let replaced =
+              Strings.intercalate " Neg" (Strings.splitOn "-" (Strings.intercalate "Dot" (Strings.splitOn "." (Strings.intercalate " Plus" (Strings.splitOn "+" (Strings.intercalate " Div" (Strings.splitOn "/" (Strings.intercalate " Mul" (Strings.splitOn "*" (Strings.intercalate " Num" (Strings.splitOn "#" name)))))))))))
+          sanitized = Formatting.nonAlnumToUnderscores replaced
+          pascal_ = Formatting.convertCase Util.CaseConventionLowerSnake Util.CaseConventionPascal sanitized
+      in (Strings.cat2 "test" pascal_)
+
+-- | Generate a single JUnit test case from a test case with metadata
+generateJavaTestCase :: [String] -> Testing.TestCaseWithMetadata -> Either t0 [String]
+generateJavaTestCase groupPath tcm =
+
+      let name_ = Testing.testCaseWithMetadataName tcm
+          tcase = Testing.testCaseWithMetadataCase tcm
+      in case tcase of
+        Testing.TestCaseUniversal v0 ->
+          let actual_ = Testing.universalTestCaseActual v0 ()
+              expected_ = Testing.universalTestCaseExpected v0 ()
+              fullName = Logic.ifElse (Lists.null groupPath) name_ (Strings.intercalate "_" (Lists.concat2 groupPath [
+                    name_]))
+              formattedName = formatJavaTestName fullName
+          in (Right [
+            "    @Test",
+            (Strings.cat [
+              "    public void ",
+              formattedName,
+              "() {"]),
+            "        assertEquals(",
+            (Strings.cat [
+              "            ",
+              expected_,
+              ","]),
+            (Strings.cat [
+              "            ",
+              actual_,
+              ");"]),
+            "    }"])
+
+-- | Generate a Java test file for a test group
+generateJavaTestFile :: Packaging.Module -> Testing.TestGroup -> t0 -> Either t1 (String, String)
+generateJavaTestFile testModule testGroup _g = generateTestFileWithJavaCodec testModule testGroup
+
+-- | Generate test hierarchy for Java with nested subgroups
+generateJavaTestGroupHierarchy :: [String] -> Testing.TestGroup -> Either t0 String
+generateJavaTestGroupHierarchy groupPath testGroup =
+
+      let cases_ = Testing.testGroupCases testGroup
+          subgroups = Testing.testGroupSubgroups testGroup
+      in (Eithers.bind (Eithers.map (\lines_ -> Strings.intercalate "\n\n" (Lists.concat lines_)) (Eithers.mapList (\tc -> generateJavaTestCase groupPath tc) cases_)) (\testCasesStr -> Eithers.map (\subgroupsStr -> Strings.cat [
+        testCasesStr,
+        (Logic.ifElse (Logic.or (Equality.equal testCasesStr "") (Equality.equal subgroupsStr "")) "" "\n\n"),
+        subgroupsStr]) (Eithers.map (\blocks -> Strings.intercalate "\n\n" blocks) (Eithers.mapList (\subgroup ->
+        let groupName = Testing.testGroupName subgroup
+            header = Strings.cat2 "    // " groupName
+        in (Eithers.map (\content -> Strings.cat [
+          header,
+          "\n\n",
+          content]) (generateJavaTestGroupHierarchy (Lists.concat2 groupPath [
+          groupName]) subgroup))) subgroups))))
+
+-- | Generate a complete test file for Java
+generateTestFileWithJavaCodec :: Packaging.Module -> Testing.TestGroup -> Either t0 (String, String)
+generateTestFileWithJavaCodec testModule testGroup =
+    Eithers.map (\testBody ->
+      let testModuleContent = buildJavaTestModule testModule testGroup testBody
+          ns_ = Packaging.moduleName testModule
+          parts = Strings.splitOn "." (Packaging.unModuleName ns_)
+          dirParts = Lists.drop 1 (Optionals.fromOptional [] (Lists.maybeInit parts))
+          className_ = Strings.cat2 (Formatting.capitalize (Optionals.fromOptional "" (Lists.maybeLast parts))) "Test"
+          fileName = Strings.cat2 className_ ".java"
+          filePath =
+                  Strings.cat [
+                    Strings.intercalate "/" dirParts,
+                    "/",
+                    fileName]
+      in (filePath, testModuleContent)) (generateJavaTestGroupHierarchy [] testGroup)
+
+-- | Convert namespace to Java class name
+namespaceToJavaClassName :: Packaging.ModuleName -> String
+namespaceToJavaClassName ns_ =
+    Strings.intercalate "." (Lists.map Formatting.capitalize (Strings.splitOn "." (Packaging.unModuleName ns_)))
diff --git a/src/main/haskell/Hydra/Java/Utils.hs b/src/main/haskell/Hydra/Java/Utils.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Java/Utils.hs
@@ -0,0 +1,1150 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Java utilities for constructing Java syntax trees
+
+module Hydra.Java.Utils where
+
+import qualified Hydra.Ast as Ast
+import qualified Hydra.Classes as Classes
+import qualified Hydra.Coders as Coders
+import qualified Hydra.Core as Core
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Errors as Errors
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Java.Environment as Environment
+import qualified Hydra.Java.Language as Language
+import qualified Hydra.Java.Names as JavaNames
+import qualified Hydra.Java.Serde as Serde
+import qualified Hydra.Java.Syntax as Syntax
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers
+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps
+import qualified Hydra.Overlay.Haskell.Lib.Math as Math
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+import qualified Hydra.Names as Names
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Serialization as Serialization
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+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.Map as M
+
+addExpressions :: [Syntax.MultiplicativeExpression] -> Syntax.AdditiveExpression
+addExpressions exprs =
+
+      let dummyMult =
+              Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionLiteral (Syntax.LiteralInteger (Syntax.IntegerLiteral 0)))))))
+      in (Lists.foldl (\ae -> \me -> Syntax.AdditiveExpressionPlus (Syntax.AdditiveExpression_Binary {
+        Syntax.additiveExpression_BinaryLhs = ae,
+        Syntax.additiveExpression_BinaryRhs = me})) (Syntax.AdditiveExpressionUnary (Optionals.fromOptional dummyMult (Lists.maybeHead exprs))) (Lists.drop 1 exprs))
+
+addInScopeVar :: Core.Name -> Environment.Aliases -> Environment.Aliases
+addInScopeVar name aliases =
+    Environment.Aliases {
+      Environment.aliasesCurrentNamespace = (Environment.aliasesCurrentNamespace aliases),
+      Environment.aliasesPackages = (Environment.aliasesPackages aliases),
+      Environment.aliasesBranchVars = (Environment.aliasesBranchVars aliases),
+      Environment.aliasesRecursiveVars = (Environment.aliasesRecursiveVars aliases),
+      Environment.aliasesInScopeTypeParams = (Environment.aliasesInScopeTypeParams aliases),
+      Environment.aliasesPolymorphicLocals = (Environment.aliasesPolymorphicLocals aliases),
+      Environment.aliasesInScopeJavaVars = (Sets.insert name (Environment.aliasesInScopeJavaVars aliases)),
+      Environment.aliasesVarRenames = (Environment.aliasesVarRenames aliases),
+      Environment.aliasesLambdaVars = (Environment.aliasesLambdaVars aliases),
+      Environment.aliasesTypeVarSubst = (Environment.aliasesTypeVarSubst aliases),
+      Environment.aliasesTrustedTypeVars = (Environment.aliasesTrustedTypeVars aliases),
+      Environment.aliasesMethodCodomain = (Environment.aliasesMethodCodomain aliases),
+      Environment.aliasesThunkedVars = (Environment.aliasesThunkedVars aliases)}
+
+addInScopeVars :: [Core.Name] -> Environment.Aliases -> Environment.Aliases
+addInScopeVars names aliases = Lists.foldl (\a -> \n -> addInScopeVar n a) aliases names
+
+addJavaTypeParameter :: Syntax.ReferenceType -> Syntax.Type -> t0 -> Either Errors.Error Syntax.Type
+addJavaTypeParameter rt t cx =
+    case t of
+      Syntax.TypeReference v0 -> case v0 of
+        Syntax.ReferenceTypeClassOrInterface v1 -> case v1 of
+          Syntax.ClassOrInterfaceTypeClass v2 ->
+            let anns = Syntax.classTypeAnnotations v2
+                qual = Syntax.classTypeQualifier v2
+                id = Syntax.classTypeIdentifier v2
+                args = Syntax.classTypeArguments v2
+            in (Right (Syntax.TypeReference (Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeClass (Syntax.ClassType {
+              Syntax.classTypeAnnotations = anns,
+              Syntax.classTypeQualifier = qual,
+              Syntax.classTypeIdentifier = id,
+              Syntax.classTypeArguments = (Lists.concat2 args [
+                Syntax.TypeArgumentReference rt])})))))
+          Syntax.ClassOrInterfaceTypeInterface _ -> Left (Errors.ErrorOther (Errors.OtherError "expected a Java class type"))
+        Syntax.ReferenceTypeVariable v1 -> Right (javaTypeVariableToType v1)
+        Syntax.ReferenceTypeArray _ -> Left (Errors.ErrorOther (Errors.OtherError "expected a Java class or interface type, or a variable"))
+      Syntax.TypePrimitive _ -> Left (Errors.ErrorOther (Errors.OtherError "expected a reference type"))
+
+addVarRename :: Core.Name -> Core.Name -> Environment.Aliases -> Environment.Aliases
+addVarRename original renamed aliases =
+    Environment.Aliases {
+      Environment.aliasesCurrentNamespace = (Environment.aliasesCurrentNamespace aliases),
+      Environment.aliasesPackages = (Environment.aliasesPackages aliases),
+      Environment.aliasesBranchVars = (Environment.aliasesBranchVars aliases),
+      Environment.aliasesRecursiveVars = (Environment.aliasesRecursiveVars aliases),
+      Environment.aliasesInScopeTypeParams = (Environment.aliasesInScopeTypeParams aliases),
+      Environment.aliasesPolymorphicLocals = (Environment.aliasesPolymorphicLocals aliases),
+      Environment.aliasesInScopeJavaVars = (Environment.aliasesInScopeJavaVars aliases),
+      Environment.aliasesVarRenames = (Maps.insert original renamed (Environment.aliasesVarRenames aliases)),
+      Environment.aliasesLambdaVars = (Environment.aliasesLambdaVars aliases),
+      Environment.aliasesTypeVarSubst = (Environment.aliasesTypeVarSubst aliases),
+      Environment.aliasesTrustedTypeVars = (Environment.aliasesTrustedTypeVars aliases),
+      Environment.aliasesMethodCodomain = (Environment.aliasesMethodCodomain aliases),
+      Environment.aliasesThunkedVars = (Environment.aliasesThunkedVars aliases)}
+
+fieldExpression :: Syntax.Identifier -> Syntax.Identifier -> Syntax.ExpressionName
+fieldExpression varId fieldId =
+    Syntax.ExpressionName {
+      Syntax.expressionNameQualifier = (Just (Syntax.AmbiguousName [
+        varId])),
+      Syntax.expressionNameIdentifier = fieldId}
+
+fieldNameToJavaExpression :: Core.Name -> Syntax.Expression
+fieldNameToJavaExpression fname =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionName (javaIdentifierToJavaExpressionName (fieldNameToJavaIdentifier fname)))))))))]]]]])))
+
+fieldNameToJavaIdentifier :: Core.Name -> Syntax.Identifier
+fieldNameToJavaIdentifier fname = javaIdentifier (Core.unName fname)
+
+fieldNameToJavaVariableDeclarator :: Core.Name -> Syntax.VariableDeclarator
+fieldNameToJavaVariableDeclarator fname = javaVariableDeclarator (javaIdentifier (Core.unName fname)) Nothing
+
+fieldNameToJavaVariableDeclaratorId :: Core.Name -> Syntax.VariableDeclaratorId
+fieldNameToJavaVariableDeclaratorId fname = javaVariableDeclaratorId (javaIdentifier (Core.unName fname))
+
+finalVarDeclarationStatement :: Syntax.Identifier -> Syntax.Expression -> Syntax.BlockStatement
+finalVarDeclarationStatement id rhs =
+    Syntax.BlockStatementLocalVariableDeclaration (Syntax.LocalVariableDeclarationStatement (Syntax.LocalVariableDeclaration {
+      Syntax.localVariableDeclarationModifiers = [
+        Syntax.VariableModifierFinal],
+      Syntax.localVariableDeclarationType = Syntax.LocalVariableTypeVar,
+      Syntax.localVariableDeclarationDeclarators = [
+        javaVariableDeclarator id (Just (Syntax.VariableInitializerExpression rhs))]}))
+
+importAliasesForModule :: Packaging.Module -> Environment.Aliases
+importAliasesForModule mod =
+    Environment.Aliases {
+      Environment.aliasesCurrentNamespace = (Packaging.moduleName mod),
+      Environment.aliasesPackages = overlayJavaLibPackageAliases,
+      Environment.aliasesBranchVars = Sets.empty,
+      Environment.aliasesRecursiveVars = Sets.empty,
+      Environment.aliasesInScopeTypeParams = Sets.empty,
+      Environment.aliasesPolymorphicLocals = Sets.empty,
+      Environment.aliasesInScopeJavaVars = Sets.empty,
+      Environment.aliasesVarRenames = Maps.empty,
+      Environment.aliasesLambdaVars = Sets.empty,
+      Environment.aliasesTypeVarSubst = Maps.empty,
+      Environment.aliasesTrustedTypeVars = Sets.empty,
+      Environment.aliasesMethodCodomain = Nothing,
+      Environment.aliasesThunkedVars = Sets.empty}
+
+interfaceMethodDeclaration :: [Syntax.InterfaceMethodModifier] -> [Syntax.TypeParameter] -> String -> [Syntax.FormalParameter] -> Syntax.Result -> Maybe [Syntax.BlockStatement] -> Syntax.InterfaceMemberDeclaration
+interfaceMethodDeclaration mods tparams methodName params result stmts =
+    Syntax.InterfaceMemberDeclarationInterfaceMethod (Syntax.InterfaceMethodDeclaration {
+      Syntax.interfaceMethodDeclarationModifiers = mods,
+      Syntax.interfaceMethodDeclarationHeader = (javaMethodHeader tparams methodName params result),
+      Syntax.interfaceMethodDeclarationBody = (javaMethodBody stmts)})
+
+isEscaped :: String -> Bool
+isEscaped s = Equality.equal (Optionals.fromOptional 0 (Strings.maybeCharAt 0 s)) 36
+
+javaAdditiveExpressionToJavaExpression :: Syntax.AdditiveExpression -> Syntax.Expression
+javaAdditiveExpressionToJavaExpression ae =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary ae))]]]]])))
+
+javaArrayCreation :: Syntax.PrimitiveTypeWithAnnotations -> Maybe Syntax.ArrayInitializer -> Syntax.Expression
+javaArrayCreation primType minit =
+
+      let init_ = Optionals.cases minit (Syntax.ArrayInitializer []) (\i -> i)
+      in (javaPrimaryToJavaExpression (Syntax.PrimaryArrayCreation (Syntax.ArrayCreationExpressionWithInitializer_ (Syntax.ArrayCreationExpressionWithInitializerPrimitive (Syntax.ArrayCreationExpressionWithInitializer_Primitive {
+        Syntax.arrayCreationExpressionWithInitializer_PrimitiveType = primType,
+        Syntax.arrayCreationExpressionWithInitializer_PrimitiveDims = [],
+        Syntax.arrayCreationExpressionWithInitializer_PrimitiveArray = init_})))))
+
+javaArrayInitializer :: [Syntax.Expression] -> Syntax.ArrayInitializer
+javaArrayInitializer exprs = Syntax.ArrayInitializer [
+  Lists.map (\e -> Syntax.VariableInitializerExpression e) exprs]
+
+javaAssignmentStatement :: Syntax.LeftHandSide -> Syntax.Expression -> Syntax.Statement
+javaAssignmentStatement lhs rhs =
+    Syntax.StatementWithoutTrailing (Syntax.StatementWithoutTrailingSubstatementExpression (Syntax.ExpressionStatement (Syntax.StatementExpressionAssignment (Syntax.Assignment {
+      Syntax.assignmentLhs = lhs,
+      Syntax.assignmentOp = Syntax.AssignmentOperatorSimple,
+      Syntax.assignmentExpression = rhs}))))
+
+javaBoolean :: Bool -> Syntax.Literal
+javaBoolean b = Syntax.LiteralBoolean b
+
+javaBooleanExpression :: Bool -> Syntax.Expression
+javaBooleanExpression b = javaPrimaryToJavaExpression (javaLiteralToJavaPrimary (javaBoolean b))
+
+javaBooleanType :: Syntax.Type
+javaBooleanType = javaPrimitiveTypeToJavaType Syntax.PrimitiveTypeBoolean
+
+javaBytePrimitiveType :: Syntax.PrimitiveTypeWithAnnotations
+javaBytePrimitiveType =
+    Syntax.PrimitiveTypeWithAnnotations {
+      Syntax.primitiveTypeWithAnnotationsType = (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeIntegral Syntax.IntegralTypeByte)),
+      Syntax.primitiveTypeWithAnnotationsAnnotations = []}
+
+javaCastExpression :: Syntax.ReferenceType -> Syntax.UnaryExpression -> Syntax.CastExpression
+javaCastExpression rt expr =
+    Syntax.CastExpressionNotPlusMinus (Syntax.CastExpression_NotPlusMinus {
+      Syntax.castExpression_NotPlusMinusRefAndBounds = Syntax.CastExpression_RefAndBounds {
+        Syntax.castExpression_RefAndBoundsType = rt,
+        Syntax.castExpression_RefAndBoundsBounds = []},
+      Syntax.castExpression_NotPlusMinusExpression = expr})
+
+javaCastExpressionToJavaExpression :: Syntax.CastExpression -> Syntax.Expression
+javaCastExpressionToJavaExpression ce =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusCast ce))))))]]]]])))
+
+javaCastPrimitive :: Syntax.PrimitiveType -> Syntax.UnaryExpression -> Syntax.CastExpression
+javaCastPrimitive pt expr =
+    Syntax.CastExpressionPrimitive (Syntax.CastExpression_Primitive {
+      Syntax.castExpression_PrimitiveType = Syntax.PrimitiveTypeWithAnnotations {
+        Syntax.primitiveTypeWithAnnotationsType = pt,
+        Syntax.primitiveTypeWithAnnotationsAnnotations = []},
+      Syntax.castExpression_PrimitiveExpression = expr})
+
+javaClassDeclaration :: Environment.Aliases -> [Syntax.TypeParameter] -> Core.Name -> [Syntax.ClassModifier] -> Maybe Core.Name -> [Syntax.InterfaceType] -> [Syntax.ClassBodyDeclarationWithComments] -> Syntax.ClassDeclaration
+javaClassDeclaration aliases tparams elName mods supname impls bodyDecls =
+
+      let extends_ = Optionals.map (\n -> nameToJavaClassType aliases True [] n Nothing) supname
+      in (Syntax.ClassDeclarationNormal (Syntax.NormalClassDeclaration {
+        Syntax.normalClassDeclarationModifiers = mods,
+        Syntax.normalClassDeclarationIdentifier = (javaDeclName elName),
+        Syntax.normalClassDeclarationParameters = tparams,
+        Syntax.normalClassDeclarationExtends = extends_,
+        Syntax.normalClassDeclarationImplements = impls,
+        Syntax.normalClassDeclarationPermits = [],
+        Syntax.normalClassDeclarationBody = (Syntax.ClassBody bodyDecls)}))
+
+javaClassType :: [Syntax.ReferenceType] -> Maybe Syntax.PackageName -> String -> Syntax.ClassType
+javaClassType args pkg id =
+
+      let qual = Optionals.cases pkg Syntax.ClassTypeQualifierNone (\p -> Syntax.ClassTypeQualifierPackage p)
+          targs = Lists.map (\rt -> Syntax.TypeArgumentReference rt) args
+      in Syntax.ClassType {
+        Syntax.classTypeAnnotations = [],
+        Syntax.classTypeQualifier = qual,
+        Syntax.classTypeIdentifier = (javaTypeIdentifier id),
+        Syntax.classTypeArguments = targs}
+
+javaClassTypeToJavaType :: Syntax.ClassType -> Syntax.Type
+javaClassTypeToJavaType ct =
+    Syntax.TypeReference (Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeClass ct))
+
+javaConditionalAndExpressionToJavaExpression :: Syntax.ConditionalAndExpression -> Syntax.Expression
+javaConditionalAndExpressionToJavaExpression cae =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      cae])))
+
+javaConstructorCall :: Syntax.ClassOrInterfaceTypeToInstantiate -> [Syntax.Expression] -> Maybe Syntax.ClassBody -> Syntax.Expression
+javaConstructorCall ci args mbody =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionClassInstance (Syntax.ClassInstanceCreationExpression {
+                Syntax.classInstanceCreationExpressionQualifier = Nothing,
+                Syntax.classInstanceCreationExpressionExpression = Syntax.UnqualifiedClassInstanceCreationExpression {
+                  Syntax.unqualifiedClassInstanceCreationExpressionTypeArguments = [],
+                  Syntax.unqualifiedClassInstanceCreationExpressionClassOrInterface = ci,
+                  Syntax.unqualifiedClassInstanceCreationExpressionArguments = args,
+                  Syntax.unqualifiedClassInstanceCreationExpressionBody = mbody}}))))))))))]]]]])))
+
+javaConstructorName :: Syntax.Identifier -> Maybe Syntax.TypeArgumentsOrDiamond -> Syntax.ClassOrInterfaceTypeToInstantiate
+javaConstructorName id targs =
+    Syntax.ClassOrInterfaceTypeToInstantiate {
+      Syntax.classOrInterfaceTypeToInstantiateIdentifiers = [
+        Syntax.AnnotatedIdentifier {
+          Syntax.annotatedIdentifierAnnotations = [],
+          Syntax.annotatedIdentifierIdentifier = id}],
+      Syntax.classOrInterfaceTypeToInstantiateTypeArguments = targs}
+
+javaDeclName :: Core.Name -> Syntax.TypeIdentifier
+javaDeclName name = Syntax.TypeIdentifier (javaVariableName name)
+
+javaDoubleCastExpression :: Syntax.ReferenceType -> Syntax.ReferenceType -> Syntax.UnaryExpression -> Syntax.CastExpression
+javaDoubleCastExpression rawRt targetRt expr =
+
+      let firstCast = javaCastExpressionToJavaExpression (javaCastExpression rawRt expr)
+      in (javaCastExpression targetRt (javaExpressionToJavaUnaryExpression firstCast))
+
+javaDoubleCastExpressionToJavaExpression :: Syntax.ReferenceType -> Syntax.ReferenceType -> Syntax.UnaryExpression -> Syntax.Expression
+javaDoubleCastExpressionToJavaExpression rawRt targetRt expr =
+    javaCastExpressionToJavaExpression (javaDoubleCastExpression rawRt targetRt expr)
+
+javaEmptyStatement :: Syntax.Statement
+javaEmptyStatement = Syntax.StatementWithoutTrailing Syntax.StatementWithoutTrailingSubstatementEmpty
+
+javaEqualityExpressionToJavaExpression :: Syntax.EqualityExpression -> Syntax.Expression
+javaEqualityExpressionToJavaExpression ee =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              ee]]]]])))
+
+javaEqualityExpressionToJavaInclusiveOrExpression :: Syntax.EqualityExpression -> Syntax.InclusiveOrExpression
+javaEqualityExpressionToJavaInclusiveOrExpression ee =
+    Syntax.InclusiveOrExpression [
+      Syntax.ExclusiveOrExpression [
+        Syntax.AndExpression [
+          ee]]]
+
+javaEquals :: Syntax.EqualityExpression -> Syntax.RelationalExpression -> Syntax.EqualityExpression
+javaEquals lhs rhs =
+    Syntax.EqualityExpressionEqual (Syntax.EqualityExpression_Binary {
+      Syntax.equalityExpression_BinaryLhs = lhs,
+      Syntax.equalityExpression_BinaryRhs = rhs})
+
+javaEqualsNull :: Syntax.EqualityExpression -> Syntax.EqualityExpression
+javaEqualsNull lhs = javaEquals lhs (javaLiteralToJavaRelationalExpression Syntax.LiteralNull)
+
+javaExpressionNameToJavaExpression :: Syntax.ExpressionName -> Syntax.Expression
+javaExpressionNameToJavaExpression en =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionName en)))))))]]]]])))
+
+-- | Convert an Expression to a Primary, avoiding unnecessary parentheses when the expression is already a simple primary chain
+javaExpressionToJavaPrimary :: Syntax.Expression -> Syntax.Primary
+javaExpressionToJavaPrimary e =
+
+      let fallback = Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionParens e)
+      in case e of
+        Syntax.ExpressionAssignment v0 -> case v0 of
+          Syntax.AssignmentExpressionConditional v1 -> case v1 of
+            Syntax.ConditionalExpressionSimple v2 ->
+              let cands = Syntax.unConditionalOrExpression v2
+              in (Optionals.fromOptional fallback (Optionals.bind (Lists.maybeHead cands) (\candHead ->
+                let iors = Syntax.unConditionalAndExpression candHead
+                in (Optionals.bind (Lists.maybeHead iors) (\iorHead ->
+                  let xors = Syntax.unInclusiveOrExpression iorHead
+                  in (Optionals.bind (Lists.maybeHead xors) (\xorHead ->
+                    let ands = Syntax.unExclusiveOrExpression xorHead
+                    in (Optionals.bind (Lists.maybeHead ands) (\andHead ->
+                      let eqs = Syntax.unAndExpression andHead
+                      in (Optionals.bind (Lists.maybeHead eqs) (\eqHead -> Just (case eqHead of
+                        Syntax.EqualityExpressionUnary v3 -> case v3 of
+                          Syntax.RelationalExpressionSimple v4 -> case v4 of
+                            Syntax.ShiftExpressionUnary v5 -> case v5 of
+                              Syntax.AdditiveExpressionUnary v6 -> case v6 of
+                                Syntax.MultiplicativeExpressionUnary v7 -> case v7 of
+                                  Syntax.UnaryExpressionOther v8 -> case v8 of
+                                    Syntax.UnaryExpressionNotPlusMinusPostfix v9 -> case v9 of
+                                      Syntax.PostfixExpressionPrimary v10 -> v10
+                                      _ -> fallback
+                                    _ -> fallback
+                                  _ -> fallback
+                                _ -> fallback
+                              _ -> fallback
+                            _ -> fallback
+                          _ -> fallback
+                        _ -> fallback))))))))))))
+            _ -> fallback
+          _ -> fallback
+        _ -> fallback
+
+javaExpressionToJavaUnaryExpression :: Syntax.Expression -> Syntax.UnaryExpression
+javaExpressionToJavaUnaryExpression e =
+    Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionParens e))))
+
+javaFieldAccessToJavaExpression :: Syntax.FieldAccess -> Syntax.Expression
+javaFieldAccessToJavaExpression fa =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionFieldAccess fa)))))))))]]]]])))
+
+javaIdentifier :: String -> Syntax.Identifier
+javaIdentifier s = Syntax.Identifier (sanitizeJavaName s)
+
+javaIdentifierToJavaExpression :: Syntax.Identifier -> Syntax.Expression
+javaIdentifierToJavaExpression id =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionName (Syntax.ExpressionName {
+                Syntax.expressionNameQualifier = Nothing,
+                Syntax.expressionNameIdentifier = id}))))))))]]]]])))
+
+javaIdentifierToJavaExpressionName :: Syntax.Identifier -> Syntax.ExpressionName
+javaIdentifierToJavaExpressionName id =
+    Syntax.ExpressionName {
+      Syntax.expressionNameQualifier = Nothing,
+      Syntax.expressionNameIdentifier = id}
+
+javaIdentifierToJavaRelationalExpression :: Syntax.Identifier -> Syntax.RelationalExpression
+javaIdentifierToJavaRelationalExpression id =
+    Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionName (Syntax.ExpressionName {
+      Syntax.expressionNameQualifier = Nothing,
+      Syntax.expressionNameIdentifier = id})))))))
+
+javaIdentifierToJavaUnaryExpression :: Syntax.Identifier -> Syntax.UnaryExpression
+javaIdentifierToJavaUnaryExpression id =
+    Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionName (Syntax.ExpressionName {
+      Syntax.expressionNameQualifier = Nothing,
+      Syntax.expressionNameIdentifier = id})))
+
+javaInstanceOf :: Syntax.RelationalExpression -> Syntax.ReferenceType -> Syntax.RelationalExpression
+javaInstanceOf lhs rhs =
+    Syntax.RelationalExpressionInstanceofExpression (Syntax.InstanceofExpression {
+      Syntax.instanceofExpressionLhs = lhs,
+      Syntax.instanceofExpressionRhs = (Syntax.InstanceofExpression_RhsReferenceType rhs)})
+
+javaInt :: Integer -> Syntax.Literal
+javaInt i = Syntax.LiteralInteger (Syntax.IntegerLiteral i)
+
+javaIntExpression :: Integer -> Syntax.Expression
+javaIntExpression i = javaPrimaryToJavaExpression (javaLiteralToJavaPrimary (javaInt i))
+
+javaIntType :: Syntax.Type
+javaIntType = javaPrimitiveTypeToJavaType (Syntax.PrimitiveTypeNumeric (Syntax.NumericTypeIntegral Syntax.IntegralTypeInt))
+
+javaInterfaceDeclarationToJavaClassBodyDeclaration :: Syntax.NormalInterfaceDeclaration -> Syntax.ClassBodyDeclaration
+javaInterfaceDeclarationToJavaClassBodyDeclaration nid =
+    Syntax.ClassBodyDeclarationClassMember (Syntax.ClassMemberDeclarationInterface (Syntax.InterfaceDeclarationNormalInterface nid))
+
+javaLambda :: Core.Name -> Syntax.Expression -> Syntax.Expression
+javaLambda v body =
+    Syntax.ExpressionLambda (Syntax.LambdaExpression {
+      Syntax.lambdaExpressionParameters = (Syntax.LambdaParametersSingle (variableToJavaIdentifier v)),
+      Syntax.lambdaExpressionBody = (Syntax.LambdaBodyExpression body)})
+
+javaLambdaFromBlock :: Core.Name -> Syntax.Block -> Syntax.Expression
+javaLambdaFromBlock v block =
+    Syntax.ExpressionLambda (Syntax.LambdaExpression {
+      Syntax.lambdaExpressionParameters = (Syntax.LambdaParametersSingle (variableToJavaIdentifier v)),
+      Syntax.lambdaExpressionBody = (Syntax.LambdaBodyBlock block)})
+
+javaLiteralToJavaExpression :: Syntax.Literal -> Syntax.Expression
+javaLiteralToJavaExpression lit =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionLiteral lit)))))))))]]]]])))
+
+javaLiteralToJavaMultiplicativeExpression :: Syntax.Literal -> Syntax.MultiplicativeExpression
+javaLiteralToJavaMultiplicativeExpression lit =
+    Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionLiteral lit)))))
+
+javaLiteralToJavaPrimary :: Syntax.Literal -> Syntax.Primary
+javaLiteralToJavaPrimary lit = Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionLiteral lit)
+
+javaLiteralToJavaRelationalExpression :: Syntax.Literal -> Syntax.RelationalExpression
+javaLiteralToJavaRelationalExpression lit =
+    Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionLiteral lit))))))))
+
+javaMemberField :: [Syntax.FieldModifier] -> Syntax.Type -> Syntax.VariableDeclarator -> Syntax.ClassBodyDeclaration
+javaMemberField mods jt v =
+    Syntax.ClassBodyDeclarationClassMember (Syntax.ClassMemberDeclarationField (Syntax.FieldDeclaration {
+      Syntax.fieldDeclarationModifiers = mods,
+      Syntax.fieldDeclarationUnannType = (Syntax.UnannType jt),
+      Syntax.fieldDeclarationVariableDeclarators = [
+        v]}))
+
+javaMethodBody :: Maybe [Syntax.BlockStatement] -> Syntax.MethodBody
+javaMethodBody mstmts =
+    Optionals.cases mstmts Syntax.MethodBodyNone (\stmts -> Syntax.MethodBodyBlock (Syntax.Block stmts))
+
+javaMethodDeclarationToJavaClassBodyDeclaration :: Syntax.MethodDeclaration -> Syntax.ClassBodyDeclaration
+javaMethodDeclarationToJavaClassBodyDeclaration md =
+    Syntax.ClassBodyDeclarationClassMember (Syntax.ClassMemberDeclarationMethod md)
+
+javaMethodHeader :: [Syntax.TypeParameter] -> String -> [Syntax.FormalParameter] -> Syntax.Result -> Syntax.MethodHeader
+javaMethodHeader tparams methodName params result =
+    Syntax.MethodHeader {
+      Syntax.methodHeaderParameters = tparams,
+      Syntax.methodHeaderResult = result,
+      Syntax.methodHeaderDeclarator = Syntax.MethodDeclarator {
+        Syntax.methodDeclaratorIdentifier = (Syntax.Identifier methodName),
+        Syntax.methodDeclaratorReceiverParameter = Nothing,
+        Syntax.methodDeclaratorFormalParameters = params},
+      Syntax.methodHeaderThrows = Nothing}
+
+javaMethodInvocationToJavaExpression :: Syntax.MethodInvocation -> Syntax.Expression
+javaMethodInvocationToJavaExpression mi =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionMethodInvocation mi)))))))))]]]]])))
+
+javaMethodInvocationToJavaPostfixExpression :: Syntax.MethodInvocation -> Syntax.PostfixExpression
+javaMethodInvocationToJavaPostfixExpression mi =
+    Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionMethodInvocation mi))
+
+javaMethodInvocationToJavaPrimary :: Syntax.MethodInvocation -> Syntax.Primary
+javaMethodInvocationToJavaPrimary mi = Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionMethodInvocation mi)
+
+javaMethodInvocationToJavaStatement :: Syntax.MethodInvocation -> Syntax.Statement
+javaMethodInvocationToJavaStatement mi =
+    Syntax.StatementWithoutTrailing (Syntax.StatementWithoutTrailingSubstatementExpression (Syntax.ExpressionStatement (Syntax.StatementExpressionMethodInvocation mi)))
+
+javaMultiplicativeExpressionToJavaRelationalExpression :: Syntax.MultiplicativeExpression -> Syntax.RelationalExpression
+javaMultiplicativeExpressionToJavaRelationalExpression me =
+    Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary me))
+
+javaPackageDeclaration :: Packaging.ModuleName -> Syntax.PackageDeclaration
+javaPackageDeclaration ns =
+    Syntax.PackageDeclaration {
+      Syntax.packageDeclarationModifiers = [],
+      Syntax.packageDeclarationIdentifiers = (Lists.map (\s -> Syntax.Identifier s) (Strings.splitOn "." (Packaging.unModuleName ns)))}
+
+javaPostfixExpressionToJavaEqualityExpression :: Syntax.PostfixExpression -> Syntax.EqualityExpression
+javaPostfixExpressionToJavaEqualityExpression pe =
+    Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix pe))))))
+
+javaPostfixExpressionToJavaExpression :: Syntax.PostfixExpression -> Syntax.Expression
+javaPostfixExpressionToJavaExpression pe =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix pe))))))]]]]])))
+
+javaPostfixExpressionToJavaInclusiveOrExpression :: Syntax.PostfixExpression -> Syntax.InclusiveOrExpression
+javaPostfixExpressionToJavaInclusiveOrExpression pe =
+    Syntax.InclusiveOrExpression [
+      Syntax.ExclusiveOrExpression [
+        Syntax.AndExpression [
+          Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix pe))))))]]]
+
+javaPostfixExpressionToJavaRelationalExpression :: Syntax.PostfixExpression -> Syntax.RelationalExpression
+javaPostfixExpressionToJavaRelationalExpression pe =
+    Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix pe)))))
+
+javaPostfixExpressionToJavaUnaryExpression :: Syntax.PostfixExpression -> Syntax.UnaryExpression
+javaPostfixExpressionToJavaUnaryExpression pe = Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix pe)
+
+javaPrimaryToJavaExpression :: Syntax.Primary -> Syntax.Expression
+javaPrimaryToJavaExpression p =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary p)))))))]]]]])))
+
+javaPrimaryToJavaUnaryExpression :: Syntax.Primary -> Syntax.UnaryExpression
+javaPrimaryToJavaUnaryExpression p =
+    Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary p))
+
+javaPrimitiveTypeToJavaType :: Syntax.PrimitiveType -> Syntax.Type
+javaPrimitiveTypeToJavaType pt =
+    Syntax.TypePrimitive (Syntax.PrimitiveTypeWithAnnotations {
+      Syntax.primitiveTypeWithAnnotationsType = pt,
+      Syntax.primitiveTypeWithAnnotationsAnnotations = []})
+
+javaRefType :: [Syntax.ReferenceType] -> Maybe Syntax.PackageName -> String -> Syntax.Type
+javaRefType args pkg id =
+    Syntax.TypeReference (Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeClass (javaClassType args pkg id)))
+
+javaReferenceTypeToRawType :: Syntax.ReferenceType -> Syntax.ReferenceType
+javaReferenceTypeToRawType rt =
+    case rt of
+      Syntax.ReferenceTypeClassOrInterface v0 -> case v0 of
+        Syntax.ClassOrInterfaceTypeClass v1 ->
+          let anns = Syntax.classTypeAnnotations v1
+              qual = Syntax.classTypeQualifier v1
+              id = Syntax.classTypeIdentifier v1
+          in (Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeClass (Syntax.ClassType {
+            Syntax.classTypeAnnotations = anns,
+            Syntax.classTypeQualifier = qual,
+            Syntax.classTypeIdentifier = id,
+            Syntax.classTypeArguments = []})))
+        Syntax.ClassOrInterfaceTypeInterface v1 ->
+          let ct = Syntax.unInterfaceType v1
+              anns = Syntax.classTypeAnnotations ct
+              qual = Syntax.classTypeQualifier ct
+              id = Syntax.classTypeIdentifier ct
+          in (Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeInterface (Syntax.InterfaceType (Syntax.ClassType {
+            Syntax.classTypeAnnotations = anns,
+            Syntax.classTypeQualifier = qual,
+            Syntax.classTypeIdentifier = id,
+            Syntax.classTypeArguments = []}))))
+      _ -> rt
+
+javaRelationalExpressionToJavaEqualityExpression :: Syntax.RelationalExpression -> Syntax.EqualityExpression
+javaRelationalExpressionToJavaEqualityExpression re = Syntax.EqualityExpressionUnary re
+
+javaRelationalExpressionToJavaExpression :: Syntax.RelationalExpression -> Syntax.Expression
+javaRelationalExpressionToJavaExpression re = javaEqualityExpressionToJavaExpression (Syntax.EqualityExpressionUnary re)
+
+javaRelationalExpressionToJavaUnaryExpression :: Syntax.RelationalExpression -> Syntax.UnaryExpression
+javaRelationalExpressionToJavaUnaryExpression re =
+    Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray (Syntax.PrimaryNoNewArrayExpressionParens (Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary re]]]]]))))))))
+
+javaReturnStatement :: Maybe Syntax.Expression -> Syntax.Statement
+javaReturnStatement mex =
+    Syntax.StatementWithoutTrailing (Syntax.StatementWithoutTrailingSubstatementReturn (Syntax.ReturnStatement mex))
+
+javaStatementsToBlock :: [Syntax.Statement] -> Syntax.Block
+javaStatementsToBlock stmts = Syntax.Block (Lists.map (\s -> Syntax.BlockStatementStatement s) stmts)
+
+javaString :: String -> Syntax.Literal
+javaString s = Syntax.LiteralString (Syntax.StringLiteral s)
+
+javaStringMultiplicativeExpression :: String -> Syntax.MultiplicativeExpression
+javaStringMultiplicativeExpression s = javaLiteralToJavaMultiplicativeExpression (javaString s)
+
+javaThis :: Syntax.Expression
+javaThis =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary (Syntax.UnaryExpressionOther (Syntax.UnaryExpressionNotPlusMinusPostfix (Syntax.PostfixExpressionPrimary (Syntax.PrimaryNoNewArray Syntax.PrimaryNoNewArrayExpressionThis))))))))]]]]])))
+
+javaThrowIllegalArgumentException :: [Syntax.Expression] -> Syntax.Statement
+javaThrowIllegalArgumentException args =
+    javaThrowStatement (javaConstructorCall (javaConstructorName (Syntax.Identifier "IllegalArgumentException") Nothing) args Nothing)
+
+javaThrowIllegalStateException :: [Syntax.Expression] -> Syntax.Statement
+javaThrowIllegalStateException args =
+    javaThrowStatement (javaConstructorCall (javaConstructorName (Syntax.Identifier "IllegalStateException") Nothing) args Nothing)
+
+javaThrowStatement :: Syntax.Expression -> Syntax.Statement
+javaThrowStatement e =
+    Syntax.StatementWithoutTrailing (Syntax.StatementWithoutTrailingSubstatementThrow (Syntax.ThrowStatement e))
+
+javaTypeFromTypeName :: Environment.Aliases -> Core.Name -> Syntax.Type
+javaTypeFromTypeName aliases elName =
+    javaTypeVariableToType (Syntax.TypeVariable {
+      Syntax.typeVariableAnnotations = [],
+      Syntax.typeVariableIdentifier = (nameToJavaTypeIdentifier aliases False elName)})
+
+javaTypeIdentifier :: String -> Syntax.TypeIdentifier
+javaTypeIdentifier s = Syntax.TypeIdentifier (Syntax.Identifier s)
+
+javaTypeIdentifierToJavaTypeArgument :: Syntax.TypeIdentifier -> Syntax.TypeArgument
+javaTypeIdentifierToJavaTypeArgument id =
+    Syntax.TypeArgumentReference (Syntax.ReferenceTypeVariable (Syntax.TypeVariable {
+      Syntax.typeVariableAnnotations = [],
+      Syntax.typeVariableIdentifier = id}))
+
+javaTypeName :: Syntax.Identifier -> Syntax.TypeName
+javaTypeName id =
+    Syntax.TypeName {
+      Syntax.typeNameIdentifier = (Syntax.TypeIdentifier id),
+      Syntax.typeNameQualifier = Nothing}
+
+javaTypeParameter :: String -> Syntax.TypeParameter
+javaTypeParameter v =
+    Syntax.TypeParameter {
+      Syntax.typeParameterModifiers = [],
+      Syntax.typeParameterIdentifier = (javaTypeIdentifier v),
+      Syntax.typeParameterBound = Nothing}
+
+javaTypeToJavaFormalParameter :: Syntax.Type -> Core.Name -> Syntax.FormalParameter
+javaTypeToJavaFormalParameter jt fname =
+    Syntax.FormalParameterSimple (Syntax.FormalParameter_Simple {
+      Syntax.formalParameter_SimpleModifiers = [],
+      Syntax.formalParameter_SimpleType = (Syntax.UnannType jt),
+      Syntax.formalParameter_SimpleId = (fieldNameToJavaVariableDeclaratorId fname)})
+
+javaTypeToJavaReferenceType :: Syntax.Type -> t0 -> Either Errors.Error Syntax.ReferenceType
+javaTypeToJavaReferenceType t cx =
+    case t of
+      Syntax.TypeReference v0 -> Right v0
+      Syntax.TypePrimitive _ -> Left (Errors.ErrorOther (Errors.OtherError "expected a Java reference type"))
+
+javaTypeToJavaResult :: Syntax.Type -> Syntax.Result
+javaTypeToJavaResult jt = Syntax.ResultType (Syntax.UnannType jt)
+
+javaTypeToJavaTypeArgument :: Syntax.Type -> Syntax.TypeArgument
+javaTypeToJavaTypeArgument t =
+    case t of
+      Syntax.TypeReference v0 -> Syntax.TypeArgumentReference v0
+      Syntax.TypePrimitive _ -> Syntax.TypeArgumentWildcard (Syntax.Wildcard {
+        Syntax.wildcardAnnotations = [],
+        Syntax.wildcardWildcard = Nothing})
+
+javaTypeVariable :: String -> Syntax.ReferenceType
+javaTypeVariable v =
+    Syntax.ReferenceTypeVariable (Syntax.TypeVariable {
+      Syntax.typeVariableAnnotations = [],
+      Syntax.typeVariableIdentifier = (javaTypeIdentifier (Formatting.capitalize v))})
+
+javaTypeVariableToType :: Syntax.TypeVariable -> Syntax.Type
+javaTypeVariableToType tv = Syntax.TypeReference (Syntax.ReferenceTypeVariable tv)
+
+javaUnaryExpressionToJavaExpression :: Syntax.UnaryExpression -> Syntax.Expression
+javaUnaryExpressionToJavaExpression ue =
+    Syntax.ExpressionAssignment (Syntax.AssignmentExpressionConditional (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+      Syntax.ConditionalAndExpression [
+        Syntax.InclusiveOrExpression [
+          Syntax.ExclusiveOrExpression [
+            Syntax.AndExpression [
+              Syntax.EqualityExpressionUnary (Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary ue))))]]]]])))
+
+javaUnaryExpressionToJavaRelationalExpression :: Syntax.UnaryExpression -> Syntax.RelationalExpression
+javaUnaryExpressionToJavaRelationalExpression ue =
+    Syntax.RelationalExpressionSimple (Syntax.ShiftExpressionUnary (Syntax.AdditiveExpressionUnary (Syntax.MultiplicativeExpressionUnary ue)))
+
+javaVariableDeclarator :: Syntax.Identifier -> Maybe Syntax.VariableInitializer -> Syntax.VariableDeclarator
+javaVariableDeclarator id minit =
+    Syntax.VariableDeclarator {
+      Syntax.variableDeclaratorId = (javaVariableDeclaratorId id),
+      Syntax.variableDeclaratorInitializer = minit}
+
+javaVariableDeclaratorId :: Syntax.Identifier -> Syntax.VariableDeclaratorId
+javaVariableDeclaratorId id =
+    Syntax.VariableDeclaratorId {
+      Syntax.variableDeclaratorIdIdentifier = id,
+      Syntax.variableDeclaratorIdDims = Nothing}
+
+javaVariableName :: Core.Name -> Syntax.Identifier
+javaVariableName name = javaIdentifier (Names.localNameOf name)
+
+lookupJavaVarName :: Environment.Aliases -> Core.Name -> Core.Name
+lookupJavaVarName aliases name =
+    Optionals.cases (Maps.lookup name (Environment.aliasesVarRenames aliases)) name (\renamed -> renamed)
+
+makeConstructor :: Environment.Aliases -> Core.Name -> Bool -> [Syntax.FormalParameter] -> [Syntax.BlockStatement] -> Syntax.ClassBodyDeclaration
+makeConstructor aliases elName private params stmts =
+
+      let nm = Syntax.SimpleTypeName (nameToJavaTypeIdentifier aliases False elName)
+          cons =
+                  Syntax.ConstructorDeclarator {
+                    Syntax.constructorDeclaratorParameters = [],
+                    Syntax.constructorDeclaratorName = nm,
+                    Syntax.constructorDeclaratorReceiverParameter = Nothing,
+                    Syntax.constructorDeclaratorFormalParameters = params}
+          mods = [
+                Logic.ifElse private Syntax.ConstructorModifierPrivate Syntax.ConstructorModifierPublic]
+          body =
+                  Syntax.ConstructorBody {
+                    Syntax.constructorBodyInvocation = Nothing,
+                    Syntax.constructorBodyStatements = stmts}
+      in (Syntax.ClassBodyDeclarationConstructorDeclaration (Syntax.ConstructorDeclaration {
+        Syntax.constructorDeclarationModifiers = mods,
+        Syntax.constructorDeclarationConstructor = cons,
+        Syntax.constructorDeclarationThrows = Nothing,
+        Syntax.constructorDeclarationBody = body}))
+
+methodDeclaration :: [Syntax.MethodModifier] -> [Syntax.TypeParameter] -> [Syntax.Annotation] -> String -> [Syntax.FormalParameter] -> Syntax.Result -> Maybe [Syntax.BlockStatement] -> Syntax.ClassBodyDeclaration
+methodDeclaration mods tparams anns methodName params result stmts =
+    javaMethodDeclarationToJavaClassBodyDeclaration (Syntax.MethodDeclaration {
+      Syntax.methodDeclarationAnnotations = anns,
+      Syntax.methodDeclarationModifiers = mods,
+      Syntax.methodDeclarationHeader = (javaMethodHeader tparams methodName params result),
+      Syntax.methodDeclarationBody = (javaMethodBody stmts)})
+
+methodInvocation :: Maybe (Either Syntax.ExpressionName Syntax.Primary) -> Syntax.Identifier -> [Syntax.Expression] -> Syntax.MethodInvocation
+methodInvocation lhs methodName args =
+
+      let header =
+              Optionals.cases lhs (Syntax.MethodInvocation_HeaderSimple (Syntax.MethodName methodName)) (\either -> Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                Syntax.methodInvocation_ComplexVariant = (Eithers.either (\en -> Syntax.MethodInvocation_VariantExpression en) (\p -> Syntax.MethodInvocation_VariantPrimary p) either),
+                Syntax.methodInvocation_ComplexTypeArguments = [],
+                Syntax.methodInvocation_ComplexIdentifier = methodName}))
+      in Syntax.MethodInvocation {
+        Syntax.methodInvocationHeader = header,
+        Syntax.methodInvocationArguments = args}
+
+methodInvocationStatic :: Syntax.Identifier -> Syntax.Identifier -> [Syntax.Expression] -> Syntax.MethodInvocation
+methodInvocationStatic self methodName args =
+    methodInvocation (Just (Left (javaIdentifierToJavaExpressionName self))) methodName args
+
+methodInvocationStaticWithTypeArgs :: Syntax.Identifier -> Syntax.Identifier -> [Syntax.TypeArgument] -> [Syntax.Expression] -> Syntax.MethodInvocation
+methodInvocationStaticWithTypeArgs self methodName targs args =
+    Logic.ifElse (Lists.null targs) (methodInvocationStatic self methodName args) (
+      let header =
+              Syntax.MethodInvocation_HeaderComplex (Syntax.MethodInvocation_Complex {
+                Syntax.methodInvocation_ComplexVariant = (Syntax.MethodInvocation_VariantExpression (javaIdentifierToJavaExpressionName self)),
+                Syntax.methodInvocation_ComplexTypeArguments = targs,
+                Syntax.methodInvocation_ComplexIdentifier = methodName})
+      in Syntax.MethodInvocation {
+        Syntax.methodInvocationHeader = header,
+        Syntax.methodInvocationArguments = args})
+
+nameToJavaClassType :: Environment.Aliases -> Bool -> [Syntax.TypeArgument] -> Core.Name -> Maybe String -> Syntax.ClassType
+nameToJavaClassType aliases qualify args name mlocal =
+
+      let result = nameToQualifiedJavaName aliases qualify name mlocal
+          id = Pairs.first result
+          pkg = Pairs.second result
+      in Syntax.ClassType {
+        Syntax.classTypeAnnotations = [],
+        Syntax.classTypeQualifier = pkg,
+        Syntax.classTypeIdentifier = id,
+        Syntax.classTypeArguments = args}
+
+nameToJavaName :: Environment.Aliases -> Core.Name -> Syntax.Identifier
+nameToJavaName aliases name =
+
+      let qn = Names.qualifyName name
+          ns_ = Util.qualifiedNameModuleName qn
+          local = Util.qualifiedNameLocal qn
+      in (Logic.ifElse (isEscaped (Core.unName name)) (Syntax.Identifier (sanitizeJavaName local)) (Optionals.cases ns_ (Syntax.Identifier local) (\gname ->
+        let parts =
+                Optionals.cases (Maps.lookup gname (Environment.aliasesPackages aliases)) (Strings.splitOn "." (Packaging.unModuleName gname)) (\pkgName -> Lists.map (\i -> Syntax.unIdentifier i) (Syntax.unPackageName pkgName))
+            allParts = Lists.concat2 parts [
+                  sanitizeJavaName local]
+        in (Syntax.Identifier (Strings.intercalate "." allParts)))))
+
+nameToJavaReferenceType :: Environment.Aliases -> Bool -> [Syntax.TypeArgument] -> Core.Name -> Maybe String -> Syntax.ReferenceType
+nameToJavaReferenceType aliases qualify args name mlocal =
+    Syntax.ReferenceTypeClassOrInterface (Syntax.ClassOrInterfaceTypeClass (nameToJavaClassType aliases qualify args name mlocal))
+
+nameToJavaTypeIdentifier :: Environment.Aliases -> Bool -> Core.Name -> Syntax.TypeIdentifier
+nameToJavaTypeIdentifier aliases qualify name = Pairs.first (nameToQualifiedJavaName aliases qualify name Nothing)
+
+nameToQualifiedJavaName :: Environment.Aliases -> Bool -> Core.Name -> Maybe String -> (Syntax.TypeIdentifier, Syntax.ClassTypeQualifier)
+nameToQualifiedJavaName aliases qualify name mlocal =
+
+      let qn = Names.qualifyName name
+          ns_ = Util.qualifiedNameModuleName qn
+          local = Util.qualifiedNameLocal qn
+          alias =
+                  Optionals.cases ns_ Nothing (\n -> Just (Optionals.cases (Maps.lookup n (Environment.aliasesPackages aliases)) (JavaNames.javaPackageName (Strings.splitOn "." (Packaging.unModuleName n))) (\id -> id)))
+          pkg =
+                  Logic.ifElse qualify (Optionals.cases alias Syntax.ClassTypeQualifierNone (\p -> Syntax.ClassTypeQualifierPackage p)) Syntax.ClassTypeQualifierNone
+          jid =
+                  javaTypeIdentifier (Optionals.cases mlocal (sanitizeJavaName local) (\l -> Strings.cat2 (Strings.cat2 (sanitizeJavaName local) ".") (sanitizeJavaName l)))
+      in (jid, pkg)
+
+overlayJavaLibPackageAliases :: M.Map Packaging.ModuleName Syntax.PackageName
+overlayJavaLibPackageAliases =
+    Maps.fromList [
+      (
+        Packaging.ModuleName "hydra.lib.chars",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "chars"])),
+      (
+        Packaging.ModuleName "hydra.lib.effects",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "effects"])),
+      (
+        Packaging.ModuleName "hydra.lib.eithers",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "eithers"])),
+      (
+        Packaging.ModuleName "hydra.lib.equality",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "equality"])),
+      (
+        Packaging.ModuleName "hydra.lib.files",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "files"])),
+      (
+        Packaging.ModuleName "hydra.lib.lists",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "lists"])),
+      (
+        Packaging.ModuleName "hydra.lib.literals",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "literals"])),
+      (
+        Packaging.ModuleName "hydra.lib.logic",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "logic"])),
+      (
+        Packaging.ModuleName "hydra.lib.maps",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "maps"])),
+      (
+        Packaging.ModuleName "hydra.lib.math",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "math"])),
+      (
+        Packaging.ModuleName "hydra.lib.optionals",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "optionals"])),
+      (
+        Packaging.ModuleName "hydra.lib.pairs",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "pairs"])),
+      (
+        Packaging.ModuleName "hydra.lib.regex",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "regex"])),
+      (
+        Packaging.ModuleName "hydra.lib.sets",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "sets"])),
+      (
+        Packaging.ModuleName "hydra.lib.strings",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "strings"])),
+      (
+        Packaging.ModuleName "hydra.lib.system",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "system"])),
+      (
+        Packaging.ModuleName "hydra.lib.text",
+        (JavaNames.javaPackageName [
+          "hydra",
+          "overlay",
+          "java",
+          "lib",
+          "text"]))]
+
+overrideAnnotation :: Syntax.Annotation
+overrideAnnotation = Syntax.AnnotationMarker (Syntax.MarkerAnnotation (javaTypeName (Syntax.Identifier "Override")))
+
+referenceTypeToResult :: Syntax.ReferenceType -> Syntax.Result
+referenceTypeToResult rt = javaTypeToJavaResult (Syntax.TypeReference rt)
+
+sanitizeJavaName :: String -> String
+sanitizeJavaName name =
+    Logic.ifElse (isEscaped name) (unescape name) (Logic.ifElse (Equality.equal name "_") "ignored" (Formatting.sanitizeWithUnderscores Language.reservedWords name))
+
+suppressWarningsUncheckedAnnotation :: Syntax.Annotation
+suppressWarningsUncheckedAnnotation =
+    Syntax.AnnotationSingleElement (Syntax.SingleElementAnnotation {
+      Syntax.singleElementAnnotationName = (javaTypeName (Syntax.Identifier "SuppressWarnings")),
+      Syntax.singleElementAnnotationValue = (Just (Syntax.ElementValueConditionalExpression (Syntax.ConditionalExpressionSimple (Syntax.ConditionalOrExpression [
+        Syntax.ConditionalAndExpression [
+          javaPostfixExpressionToJavaInclusiveOrExpression (Syntax.PostfixExpressionPrimary (javaLiteralToJavaPrimary (javaString "unchecked")))]]))))})
+
+toAcceptMethod :: Bool -> [Syntax.TypeParameter] -> Syntax.ClassBodyDeclaration
+toAcceptMethod abstract vtparams =
+
+      let mods =
+              Logic.ifElse abstract [
+                Syntax.MethodModifierPublic,
+                Syntax.MethodModifierAbstract] [
+                Syntax.MethodModifierPublic]
+          tparams = [
+                javaTypeParameter JavaNames.visitorReturnParameter]
+          anns = Logic.ifElse abstract [] [
+                overrideAnnotation]
+          typeArgs = Lists.map (\tp -> Syntax.TypeArgumentReference (typeParameterToReferenceType tp)) vtparams
+          ref =
+                  javaClassTypeToJavaType (Syntax.ClassType {
+                    Syntax.classTypeAnnotations = [],
+                    Syntax.classTypeQualifier = Syntax.ClassTypeQualifierNone,
+                    Syntax.classTypeIdentifier = (javaTypeIdentifier JavaNames.visitorName),
+                    Syntax.classTypeArguments = (Lists.concat2 typeArgs [
+                      Syntax.TypeArgumentReference visitorTypeVariable])})
+          param = javaTypeToJavaFormalParameter ref (Core.Name "visitor")
+          result = javaTypeToJavaResult (Syntax.TypeReference visitorTypeVariable)
+          returnExpr =
+                  javaMethodInvocationToJavaExpression (methodInvocationStatic (Syntax.Identifier "visitor") (Syntax.Identifier JavaNames.visitMethodName) [
+                    javaThis])
+          body = Logic.ifElse abstract Nothing (Just [
+                Syntax.BlockStatementStatement (javaReturnStatement (Just returnExpr))])
+      in (methodDeclaration mods tparams anns JavaNames.acceptMethodName [
+        param] result body)
+
+toAssignStmt :: Core.Name -> Syntax.Statement
+toAssignStmt fname =
+
+      let id = fieldNameToJavaIdentifier fname
+          lhs =
+                  Syntax.LeftHandSideFieldAccess (Syntax.FieldAccess {
+                    Syntax.fieldAccessQualifier = (Syntax.FieldAccess_QualifierPrimary (Syntax.PrimaryNoNewArray Syntax.PrimaryNoNewArrayExpressionThis)),
+                    Syntax.fieldAccessIdentifier = id})
+          rhs = fieldNameToJavaExpression fname
+      in (javaAssignmentStatement lhs rhs)
+
+toJavaArrayType :: Syntax.Type -> t0 -> Either Errors.Error Syntax.Type
+toJavaArrayType t cx =
+    case t of
+      Syntax.TypeReference v0 -> case v0 of
+        Syntax.ReferenceTypeClassOrInterface v1 -> Right (Syntax.TypeReference (Syntax.ReferenceTypeArray (Syntax.ArrayType {
+          Syntax.arrayTypeDims = (Syntax.Dims [
+            []]),
+          Syntax.arrayTypeVariant = (Syntax.ArrayType_VariantClassOrInterface v1)})))
+        Syntax.ReferenceTypeArray v1 ->
+          let oldDims = Syntax.unDims (Syntax.arrayTypeDims v1)
+              newDims = Syntax.Dims (Lists.concat2 oldDims [
+                    []])
+              variant = Syntax.arrayTypeVariant v1
+          in (Right (Syntax.TypeReference (Syntax.ReferenceTypeArray (Syntax.ArrayType {
+            Syntax.arrayTypeDims = newDims,
+            Syntax.arrayTypeVariant = variant}))))
+        Syntax.ReferenceTypeVariable _ -> Left (Errors.ErrorOther (Errors.OtherError "don't know how to make Java reference type into array type"))
+      Syntax.TypePrimitive _ -> Left (Errors.ErrorOther (Errors.OtherError "don't know how to make Java type into array type"))
+
+typeParameterToReferenceType :: Syntax.TypeParameter -> Syntax.ReferenceType
+typeParameterToReferenceType tp =
+    javaTypeVariable (Syntax.unIdentifier (Syntax.unTypeIdentifier (Syntax.typeParameterIdentifier tp)))
+
+typeParameterToTypeArgument :: Syntax.TypeParameter -> Syntax.TypeArgument
+typeParameterToTypeArgument tp = javaTypeIdentifierToJavaTypeArgument (Syntax.typeParameterIdentifier tp)
+
+unTypeParameter :: Syntax.TypeParameter -> String
+unTypeParameter tp = Syntax.unIdentifier (Syntax.unTypeIdentifier (Syntax.typeParameterIdentifier tp))
+
+unescape :: String -> String
+unescape s = Strings.fromList (Lists.drop 1 (Strings.toList s))
+
+uniqueVarName :: Environment.Aliases -> Core.Name -> Core.Name
+uniqueVarName aliases name =
+    Logic.ifElse (Sets.member name (Environment.aliasesInScopeJavaVars aliases)) (uniqueVarName_go aliases (Core.unName name) 2) name
+
+uniqueVarName_go :: Environment.Aliases -> String -> Int -> Core.Name
+uniqueVarName_go aliases base n =
+
+      let candidate = Core.Name (Strings.cat2 base (Literals.showInt32 n))
+      in (Logic.ifElse (Sets.member candidate (Environment.aliasesInScopeJavaVars aliases)) (uniqueVarName_go aliases base (Math.add n 1)) candidate)
+
+varDeclarationStatement :: Syntax.Identifier -> Syntax.Expression -> Syntax.BlockStatement
+varDeclarationStatement id rhs =
+    Syntax.BlockStatementLocalVariableDeclaration (Syntax.LocalVariableDeclarationStatement (Syntax.LocalVariableDeclaration {
+      Syntax.localVariableDeclarationModifiers = [],
+      Syntax.localVariableDeclarationType = Syntax.LocalVariableTypeVar,
+      Syntax.localVariableDeclarationDeclarators = [
+        javaVariableDeclarator id (Just (Syntax.VariableInitializerExpression rhs))]}))
+
+variableDeclarationStatement :: t0 -> Syntax.Type -> Syntax.Identifier -> Syntax.Expression -> Syntax.BlockStatement
+variableDeclarationStatement aliases jtype id rhs =
+
+      let init_ = Syntax.VariableInitializerExpression rhs
+          vdec = javaVariableDeclarator id (Just init_)
+      in (Syntax.BlockStatementLocalVariableDeclaration (Syntax.LocalVariableDeclarationStatement (Syntax.LocalVariableDeclaration {
+        Syntax.localVariableDeclarationModifiers = [],
+        Syntax.localVariableDeclarationType = (Syntax.LocalVariableTypeType (Syntax.UnannType jtype)),
+        Syntax.localVariableDeclarationDeclarators = [
+          vdec]})))
+
+variableToJavaIdentifier :: Core.Name -> Syntax.Identifier
+variableToJavaIdentifier name =
+
+      let v = Core.unName name
+      in (Logic.ifElse (Equality.equal v "_") (Syntax.Identifier "ignored") (Syntax.Identifier (sanitizeJavaName v)))
+
+variantClassName :: Bool -> Core.Name -> Core.Name -> Core.Name
+variantClassName qualify elName fname =
+
+      let qn = Names.qualifyName elName
+          ns_ = Util.qualifiedNameModuleName qn
+          local = Util.qualifiedNameLocal qn
+          flocal = Formatting.capitalize (Core.unName fname)
+          local1 =
+                  Logic.ifElse qualify (Strings.cat2 (Strings.cat2 local ".") flocal) (Logic.ifElse (Equality.equal flocal local) (Strings.cat2 flocal "_") flocal)
+      in (Names.unqualifyName (Util.QualifiedName {
+        Util.qualifiedNameModuleName = ns_,
+        Util.qualifiedNameLocal = local1}))
+
+visitorTypeVariable :: Syntax.ReferenceType
+visitorTypeVariable = javaTypeVariable "r"