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-scala.cabal b/hydra-scala.cabal
new file mode 100644
--- /dev/null
+++ b/hydra-scala.cabal
@@ -0,0 +1,45 @@
+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-scala
+version:        0.17.0
+synopsis:       Hydra's Scala coder: emit Scala 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". Scala support for Hydra
+category:       Data
+homepage:       https://github.com/CategoricalData/hydra#readme
+bug-reports:    https://github.com/CategoricalData/hydra/issues
+author:         Joshua Shinavier <josh@fortytwo.net>
+maintainer:     Joshua Shinavier <josh@fortytwo.net>
+license:        Apache-2.0
+license-file:   LICENSE
+build-type:     Simple
+extra-source-files:
+    LICENSE
+    NOTICE
+    CHANGELOG.md
+
+source-repository head
+  type: git
+  location: https://github.com/CategoricalData/hydra
+
+library
+  exposed-modules:
+      Hydra.Dsl.Scala.Syntax
+      Hydra.Scala.Coder
+      Hydra.Scala.Language
+      Hydra.Scala.Serde
+      Hydra.Scala.Syntax
+      Hydra.Scala.Utils
+  other-modules:
+      Paths_hydra_scala
+  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
+    , scientific >=0.3.7 && <0.4
+  default-language: Haskell2010
diff --git a/src/main/haskell/Hydra/Dsl/Scala/Syntax.hs b/src/main/haskell/Hydra/Dsl/Scala/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Dsl/Scala/Syntax.hs
@@ -0,0 +1,11736 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | DSL functions for hydra.scala.syntax
+
+module Hydra.Dsl.Scala.Syntax where
+
+import qualified Hydra.Core as Core
+import qualified Hydra.Dsl.Core as DslCore
+import qualified Hydra.Scala.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
+import qualified Data.Int as I
+
+-- | DSL constructor for hydra.scala.syntax.AlternativePat
+alternativePat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.AlternativePat
+alternativePat lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),
+      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.scala.syntax.AlternativePat
+alternativePatLhs :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat
+alternativePatLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.AlternativePat
+alternativePatRhs :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat
+alternativePatRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.AlternativePat
+alternativePatWithLhs :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.AlternativePat
+alternativePatWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),
+      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.scala.syntax.AlternativePat"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.AlternativePat
+alternativePatWithRhs :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.AlternativePat
+alternativePatWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),
+      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.scala.syntax.AlternativePat"),
+              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.scala.syntax.AndType
+andType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AndType
+andType lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AndType"),
+      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.scala.syntax.AndType
+andTypeLhs :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type
+andTypeLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AndType"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.AndType
+andTypeRhs :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type
+andTypeRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AndType"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.AndType
+andTypeWithLhs :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AndType
+andTypeWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AndType"),
+      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.scala.syntax.AndType"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.AndType
+andTypeWithRhs :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AndType
+andTypeWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AndType"),
+      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.scala.syntax.AndType"),
+              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.scala.syntax.AnnotMod
+annotMod :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.AnnotMod
+annotMod init =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotMod"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm init)}]}))
+
+-- | DSL accessor for the init field of hydra.scala.syntax.AnnotMod
+annotModInit :: Typed.TypedTerm Syntax.AnnotMod -> Typed.TypedTerm Syntax.Init
+annotModInit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotMod"),
+        Core.projectionFieldName = (Core.Name "init")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the init field of hydra.scala.syntax.AnnotMod
+annotModWithInit :: Typed.TypedTerm Syntax.AnnotMod -> Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.AnnotMod
+annotModWithInit original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotMod"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.AnnotateData
+annotateData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.AnnotMod] -> Typed.TypedTerm Syntax.AnnotateData
+annotateData expr annots =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annots"),
+          Core.fieldTerm = (Typed.unTypedTerm annots)}]}))
+
+-- | DSL accessor for the annots field of hydra.scala.syntax.AnnotateData
+annotateDataAnnots :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm [Syntax.AnnotMod]
+annotateDataAnnots x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),
+        Core.projectionFieldName = (Core.Name "annots")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.AnnotateData
+annotateDataExpr :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm Syntax.Data
+annotateDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annots field of hydra.scala.syntax.AnnotateData
+annotateDataWithAnnots :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm [Syntax.AnnotMod] -> Typed.TypedTerm Syntax.AnnotateData
+annotateDataWithAnnots original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annots"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.AnnotateData
+annotateDataWithExpr :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AnnotateData
+annotateDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annots"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),
+              Core.projectionFieldName = (Core.Name "annots")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.AnnotateType
+annotateType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.AnnotMod] -> Typed.TypedTerm Syntax.AnnotateType
+annotateType tpe annots =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annots"),
+          Core.fieldTerm = (Typed.unTypedTerm annots)}]}))
+
+-- | DSL accessor for the annots field of hydra.scala.syntax.AnnotateType
+annotateTypeAnnots :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm [Syntax.AnnotMod]
+annotateTypeAnnots x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),
+        Core.projectionFieldName = (Core.Name "annots")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.AnnotateType
+annotateTypeTpe :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm Syntax.Type
+annotateTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the annots field of hydra.scala.syntax.AnnotateType
+annotateTypeWithAnnots :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm [Syntax.AnnotMod] -> Typed.TypedTerm Syntax.AnnotateType
+annotateTypeWithAnnots original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "annots"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.AnnotateType
+annotateTypeWithTpe :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AnnotateType
+annotateTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "annots"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),
+              Core.projectionFieldName = (Core.Name "annots")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.scala.syntax.AnonymousData wrapper
+anonymousData :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.AnonymousData
+anonymousData x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.AnonymousData"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for the hydra.scala.syntax.AnonymousNameType wrapper
+anonymousNameType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.AnonymousNameType
+anonymousNameType x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.AnonymousNameType"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.scala.syntax.ApplyData
+applyData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyData
+applyData fun args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Typed.unTypedTerm fun)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.ApplyData
+applyDataArgs :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm [Syntax.Data]
+applyDataArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the fun field of hydra.scala.syntax.ApplyData
+applyDataFun :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm Syntax.Data
+applyDataFun x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),
+        Core.projectionFieldName = (Core.Name "fun")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.ApplyData
+applyDataWithArgs :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyData
+applyDataWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),
+              Core.projectionFieldName = (Core.Name "fun")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the fun field of hydra.scala.syntax.ApplyData
+applyDataWithFun :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyData
+applyDataWithFun original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ApplyInfixData
+applyInfixData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyInfixData
+applyInfixData lhs op targs args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+      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 "targs"),
+          Core.fieldTerm = (Typed.unTypedTerm targs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.ApplyInfixData
+applyInfixDataArgs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm [Syntax.Data]
+applyInfixDataArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the lhs field of hydra.scala.syntax.ApplyInfixData
+applyInfixDataLhs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm Syntax.Data
+applyInfixDataLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the op field of hydra.scala.syntax.ApplyInfixData
+applyInfixDataOp :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm Syntax.NameData
+applyInfixDataOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the targs field of hydra.scala.syntax.ApplyInfixData
+applyInfixDataTargs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm [Syntax.Type]
+applyInfixDataTargs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+        Core.projectionFieldName = (Core.Name "targs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.ApplyInfixData
+applyInfixDataWithArgs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyInfixData
+applyInfixDataWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+      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.scala.syntax.ApplyInfixData"),
+              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.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "targs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.ApplyInfixData
+applyInfixDataWithLhs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyInfixData
+applyInfixDataWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+      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.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "targs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the op field of hydra.scala.syntax.ApplyInfixData
+applyInfixDataWithOp :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ApplyInfixData
+applyInfixDataWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+      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.scala.syntax.ApplyInfixData"),
+              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 "targs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "targs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the targs field of hydra.scala.syntax.ApplyInfixData
+applyInfixDataWithTargs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ApplyInfixData
+applyInfixDataWithTargs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+      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.scala.syntax.ApplyInfixData"),
+              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.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ApplyInfixType
+applyInfixType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplyInfixType
+applyInfixType lhs op rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm op)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.scala.syntax.ApplyInfixType
+applyInfixTypeLhs :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type
+applyInfixTypeLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the op field of hydra.scala.syntax.ApplyInfixType
+applyInfixTypeOp :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.NameType
+applyInfixTypeOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.ApplyInfixType
+applyInfixTypeRhs :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type
+applyInfixTypeRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.ApplyInfixType
+applyInfixTypeWithLhs :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplyInfixType
+applyInfixTypeWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+      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.scala.syntax.ApplyInfixType"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the op field of hydra.scala.syntax.ApplyInfixType
+applyInfixTypeWithOp :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.ApplyInfixType
+applyInfixTypeWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+      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.scala.syntax.ApplyInfixType"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.ApplyInfixType
+applyInfixTypeWithRhs :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplyInfixType
+applyInfixTypeWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),
+      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.scala.syntax.ApplyInfixType"),
+              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.scala.syntax.ApplyInfixType"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ApplyType
+applyType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ApplyType
+applyType tpe args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.ApplyType
+applyTypeArgs :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm [Syntax.Type]
+applyTypeArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.scala.syntax.ApplyTypeData
+applyTypeData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyTypeData
+applyTypeData lhs op targs args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+      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 "targs"),
+          Core.fieldTerm = (Typed.unTypedTerm targs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.ApplyTypeData
+applyTypeDataArgs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm [Syntax.Data]
+applyTypeDataArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the lhs field of hydra.scala.syntax.ApplyTypeData
+applyTypeDataLhs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.Data
+applyTypeDataLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the op field of hydra.scala.syntax.ApplyTypeData
+applyTypeDataOp :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.NameData
+applyTypeDataOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the targs field of hydra.scala.syntax.ApplyTypeData
+applyTypeDataTargs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm [Syntax.Type]
+applyTypeDataTargs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+        Core.projectionFieldName = (Core.Name "targs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.ApplyTypeData
+applyTypeDataWithArgs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyTypeData
+applyTypeDataWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+      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.scala.syntax.ApplyTypeData"),
+              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.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "targs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.ApplyTypeData
+applyTypeDataWithLhs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyTypeData
+applyTypeDataWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+      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.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "targs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the op field of hydra.scala.syntax.ApplyTypeData
+applyTypeDataWithOp :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ApplyTypeData
+applyTypeDataWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+      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.scala.syntax.ApplyTypeData"),
+              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 "targs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "targs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the targs field of hydra.scala.syntax.ApplyTypeData
+applyTypeDataWithTargs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ApplyTypeData
+applyTypeDataWithTargs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+      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.scala.syntax.ApplyTypeData"),
+              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.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.ApplyType
+applyTypeTpe :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm Syntax.Type
+applyTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.ApplyType
+applyTypeWithArgs :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ApplyType
+applyTypeWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.ApplyType
+applyTypeWithTpe :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplyType
+applyTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ApplyUnaryData
+applyUnaryData :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyUnaryData
+applyUnaryData op arg =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm op)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arg"),
+          Core.fieldTerm = (Typed.unTypedTerm arg)}]}))
+
+-- | DSL accessor for the arg field of hydra.scala.syntax.ApplyUnaryData
+applyUnaryDataArg :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.Data
+applyUnaryDataArg x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),
+        Core.projectionFieldName = (Core.Name "arg")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the op field of hydra.scala.syntax.ApplyUnaryData
+applyUnaryDataOp :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.NameData
+applyUnaryDataOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the arg field of hydra.scala.syntax.ApplyUnaryData
+applyUnaryDataWithArg :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyUnaryData
+applyUnaryDataWithArg original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "arg"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the op field of hydra.scala.syntax.ApplyUnaryData
+applyUnaryDataWithOp :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ApplyUnaryData
+applyUnaryDataWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "arg"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),
+              Core.projectionFieldName = (Core.Name "arg")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ApplyUsingData
+applyUsingData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyUsingData
+applyUsingData fun targs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Typed.unTypedTerm fun)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Typed.unTypedTerm targs)}]}))
+
+-- | DSL accessor for the fun field of hydra.scala.syntax.ApplyUsingData
+applyUsingDataFun :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm Syntax.Data
+applyUsingDataFun x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),
+        Core.projectionFieldName = (Core.Name "fun")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the targs field of hydra.scala.syntax.ApplyUsingData
+applyUsingDataTargs :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm [Syntax.Data]
+applyUsingDataTargs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),
+        Core.projectionFieldName = (Core.Name "targs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the fun field of hydra.scala.syntax.ApplyUsingData
+applyUsingDataWithFun :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyUsingData
+applyUsingDataWithFun original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),
+              Core.projectionFieldName = (Core.Name "targs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the targs field of hydra.scala.syntax.ApplyUsingData
+applyUsingDataWithTargs :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyUsingData
+applyUsingDataWithTargs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),
+              Core.projectionFieldName = (Core.Name "fun")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "targs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.AscribeData
+ascribeData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AscribeData
+ascribeData expr tpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.AscribeData
+ascribeDataExpr :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Data
+ascribeDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.AscribeData
+ascribeDataTpe :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Type
+ascribeDataTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.AscribeData
+ascribeDataWithExpr :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AscribeData
+ascribeDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.AscribeData
+ascribeDataWithTpe :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AscribeData
+ascribeDataWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.AssignData
+assignData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AssignData
+assignData lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AssignData"),
+      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.scala.syntax.AssignData
+assignDataLhs :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data
+assignDataLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AssignData"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.AssignData
+assignDataRhs :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data
+assignDataRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AssignData"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.AssignData
+assignDataWithLhs :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AssignData
+assignDataWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AssignData"),
+      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.scala.syntax.AssignData"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.AssignData
+assignDataWithRhs :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AssignData
+assignDataWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.AssignData"),
+      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.scala.syntax.AssignData"),
+              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.scala.syntax.BindPat
+bindPat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.BindPat
+bindPat lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.BindPat"),
+      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.scala.syntax.BindPat
+bindPatLhs :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat
+bindPatLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.BindPat"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.BindPat
+bindPatRhs :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat
+bindPatRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.BindPat"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.BindPat
+bindPatWithLhs :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.BindPat
+bindPatWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.BindPat"),
+      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.scala.syntax.BindPat"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.BindPat
+bindPatWithRhs :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.BindPat
+bindPatWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.BindPat"),
+      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.scala.syntax.BindPat"),
+              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.scala.syntax.BlockData
+blockData :: Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.BlockData
+blockData stats =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.BlockData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm stats)}]}))
+
+-- | DSL accessor for the stats field of hydra.scala.syntax.BlockData
+blockDataStats :: Typed.TypedTerm Syntax.BlockData -> Typed.TypedTerm [Syntax.Stat]
+blockDataStats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.BlockData"),
+        Core.projectionFieldName = (Core.Name "stats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the stats field of hydra.scala.syntax.BlockData
+blockDataWithStats :: Typed.TypedTerm Syntax.BlockData -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.BlockData
+blockDataWithStats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.BlockData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ByNameType
+byNameType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ByNameType
+byNameType tpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ByNameType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.ByNameType
+byNameTypeTpe :: Typed.TypedTerm Syntax.ByNameType -> Typed.TypedTerm Syntax.Type
+byNameTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ByNameType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.ByNameType
+byNameTypeWithTpe :: Typed.TypedTerm Syntax.ByNameType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ByNameType
+byNameTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ByNameType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.Case
+case_ :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Case
+case_ pat cond body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Case"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Typed.unTypedTerm pat)},
+        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.scala.syntax.Case
+caseBody :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.Data
+caseBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the cond field of hydra.scala.syntax.Case
+caseCond :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm (Maybe Syntax.Data)
+caseCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.scala.syntax.CaseGeneratorEnumerator
+caseGeneratorEnumerator :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.CaseGeneratorEnumerator
+caseGeneratorEnumerator pat rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Typed.unTypedTerm pat)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the pat field of hydra.scala.syntax.CaseGeneratorEnumerator
+caseGeneratorEnumeratorPat :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Pat
+caseGeneratorEnumeratorPat x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),
+        Core.projectionFieldName = (Core.Name "pat")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.CaseGeneratorEnumerator
+caseGeneratorEnumeratorRhs :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Data
+caseGeneratorEnumeratorRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the pat field of hydra.scala.syntax.CaseGeneratorEnumerator
+caseGeneratorEnumeratorWithPat :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.CaseGeneratorEnumerator
+caseGeneratorEnumeratorWithPat original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          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.scala.syntax.CaseGeneratorEnumerator"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.CaseGeneratorEnumerator
+caseGeneratorEnumeratorWithRhs :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.CaseGeneratorEnumerator
+caseGeneratorEnumeratorWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),
+              Core.projectionFieldName = (Core.Name "pat")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL accessor for the pat field of hydra.scala.syntax.Case
+casePat :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.Pat
+casePat x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),
+        Core.projectionFieldName = (Core.Name "pat")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the case variant of hydra.scala.syntax.CaseTree
+caseTreeCase :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.CaseTree
+caseTreeCase x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.CaseTree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "case"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the typeCase variant of hydra.scala.syntax.CaseTree
+caseTreeTypeCase :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.CaseTree
+caseTreeTypeCase x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.CaseTree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typeCase"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.Case
+caseWithBody :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Case
+caseWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Case"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),
+              Core.projectionFieldName = (Core.Name "pat")})),
+            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.scala.syntax.Case"),
+              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.scala.syntax.Case
+caseWithCond :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.Case
+caseWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Case"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),
+              Core.projectionFieldName = (Core.Name "pat")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        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.scala.syntax.Case"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the pat field of hydra.scala.syntax.Case
+caseWithPat :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Case
+caseWithPat original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Case"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          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.scala.syntax.Case"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            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.scala.syntax.Case"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ClassDefn
+classDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.ClassDefn
+classDefn mods name tparams ctor template =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Typed.unTypedTerm ctor)},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Typed.unTypedTerm template)}]}))
+
+-- | DSL accessor for the ctor field of hydra.scala.syntax.ClassDefn
+classDefnCtor :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.PrimaryCtor
+classDefnCtor x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+        Core.projectionFieldName = (Core.Name "ctor")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.ClassDefn
+classDefnMods :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm [Syntax.Mod]
+classDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.ClassDefn
+classDefnName :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.NameType
+classDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the template field of hydra.scala.syntax.ClassDefn
+classDefnTemplate :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.Template
+classDefnTemplate x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+        Core.projectionFieldName = (Core.Name "template")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.ClassDefn
+classDefnTparams :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm [Syntax.ParamType]
+classDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the ctor field of hydra.scala.syntax.ClassDefn
+classDefnWithCtor :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.ClassDefn
+classDefnWithCtor original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.ClassDefn
+classDefnWithMods :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ClassDefn
+classDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.ClassDefn
+classDefnWithName :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.ClassDefn
+classDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the template field of hydra.scala.syntax.ClassDefn
+classDefnWithTemplate :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.ClassDefn
+classDefnWithTemplate original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.ClassDefn
+classDefnWithTparams :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.ClassDefn
+classDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ContextFunctionData
+contextFunctionData :: Typed.TypedTerm [Syntax.ParamData] -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ContextFunctionData
+contextFunctionData params body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm params)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.ContextFunctionData
+contextFunctionDataBody :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm Syntax.Data
+contextFunctionDataBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the params field of hydra.scala.syntax.ContextFunctionData
+contextFunctionDataParams :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm [Syntax.ParamData]
+contextFunctionDataParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),
+        Core.projectionFieldName = (Core.Name "params")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.ContextFunctionData
+contextFunctionDataWithBody :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ContextFunctionData
+contextFunctionDataWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the params field of hydra.scala.syntax.ContextFunctionData
+contextFunctionDataWithParams :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm [Syntax.ParamData] -> Typed.TypedTerm Syntax.ContextFunctionData
+contextFunctionDataWithParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          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.scala.syntax.ContextFunctionData"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ContextFunctionType
+contextFunctionType :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ContextFunctionType
+contextFunctionType params res =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm params)},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Typed.unTypedTerm res)}]}))
+
+-- | DSL accessor for the params field of hydra.scala.syntax.ContextFunctionType
+contextFunctionTypeParams :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm [Syntax.Type]
+contextFunctionTypeParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),
+        Core.projectionFieldName = (Core.Name "params")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the res field of hydra.scala.syntax.ContextFunctionType
+contextFunctionTypeRes :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm Syntax.Type
+contextFunctionTypeRes x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),
+        Core.projectionFieldName = (Core.Name "res")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the params field of hydra.scala.syntax.ContextFunctionType
+contextFunctionTypeWithParams :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ContextFunctionType
+contextFunctionTypeWithParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),
+              Core.projectionFieldName = (Core.Name "res")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the res field of hydra.scala.syntax.ContextFunctionType
+contextFunctionTypeWithRes :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ContextFunctionType
+contextFunctionTypeWithRes original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the primary variant of hydra.scala.syntax.Ctor
+ctorPrimary :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Ctor
+ctorPrimary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Ctor"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "primary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the secondary variant of hydra.scala.syntax.Ctor
+ctorSecondary :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Ctor
+ctorSecondary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Ctor"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "secondary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the annotate variant of hydra.scala.syntax.Data
+dataAnnotate :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm Syntax.Data
+dataAnnotate x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotate"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the apply variant of hydra.scala.syntax.Data
+dataApply :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm Syntax.Data
+dataApply x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "apply"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the applyType variant of hydra.scala.syntax.Data
+dataApplyType :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.Data
+dataApplyType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "applyType"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the applyUsing variant of hydra.scala.syntax.Data
+dataApplyUsing :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm Syntax.Data
+dataApplyUsing x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "applyUsing"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ascribe variant of hydra.scala.syntax.Data
+dataAscribe :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Data
+dataAscribe x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ascribe"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the assign variant of hydra.scala.syntax.Data
+dataAssign :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data
+dataAssign x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "assign"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the block variant of hydra.scala.syntax.Data
+dataBlock :: Typed.TypedTerm Syntax.BlockData -> Typed.TypedTerm Syntax.Data
+dataBlock x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "block"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the contextFunction variant of hydra.scala.syntax.Data
+dataContextFunction :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm Syntax.Data
+dataContextFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "contextFunction"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the do variant of hydra.scala.syntax.Data
+dataDo :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data
+dataDo x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "do"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the endMarker variant of hydra.scala.syntax.Data
+dataEndMarker :: Typed.TypedTerm Syntax.EndMarkerData -> Typed.TypedTerm Syntax.Data
+dataEndMarker x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "endMarker"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the eta variant of hydra.scala.syntax.Data
+dataEta :: Typed.TypedTerm Syntax.EtaData -> Typed.TypedTerm Syntax.Data
+dataEta x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "eta"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the for variant of hydra.scala.syntax.Data
+dataFor :: Typed.TypedTerm Syntax.ForData -> Typed.TypedTerm Syntax.Data
+dataFor x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "for"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the forYield variant of hydra.scala.syntax.Data
+dataForYield :: Typed.TypedTerm Syntax.ForYieldData -> Typed.TypedTerm Syntax.Data
+dataForYield x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "forYield"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the function variant of hydra.scala.syntax.Data
+dataFunction :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm Syntax.Data
+dataFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "function"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the if variant of hydra.scala.syntax.Data
+dataIf :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data
+dataIf x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "if"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interpolate variant of hydra.scala.syntax.Data
+dataInterpolate :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm Syntax.Data
+dataInterpolate x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interpolate"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the lit variant of hydra.scala.syntax.Data
+dataLit :: Typed.TypedTerm Syntax.Lit -> Typed.TypedTerm Syntax.Data
+dataLit x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lit"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the match variant of hydra.scala.syntax.Data
+dataMatch :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm Syntax.Data
+dataMatch x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "match"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the object variant of hydra.scala.syntax.DataMember
+dataMemberObject :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.DataMember
+dataMemberObject x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.DataMember"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "object"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the pkg variant of hydra.scala.syntax.DataMember
+dataMemberPkg :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.DataMember
+dataMemberPkg x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.DataMember"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "pkg"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the new variant of hydra.scala.syntax.Data
+dataNew :: Typed.TypedTerm Syntax.NewData -> Typed.TypedTerm Syntax.Data
+dataNew x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "new"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the newAnonymous variant of hydra.scala.syntax.Data
+dataNewAnonymous :: Typed.TypedTerm Syntax.NewAnonymousData -> Typed.TypedTerm Syntax.Data
+dataNewAnonymous x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "newAnonymous"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the param variant of hydra.scala.syntax.Data
+dataParam :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm Syntax.Data
+dataParam x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "param"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the partialFunction variant of hydra.scala.syntax.Data
+dataPartialFunction :: Typed.TypedTerm Syntax.PartialFunctionData -> Typed.TypedTerm Syntax.Data
+dataPartialFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "partialFunction"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the placeholder variant of hydra.scala.syntax.Data
+dataPlaceholder :: Typed.TypedTerm Syntax.Data
+dataPlaceholder =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "placeholder"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the polyFunction variant of hydra.scala.syntax.Data
+dataPolyFunction :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm Syntax.Data
+dataPolyFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "polyFunction"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ref variant of hydra.scala.syntax.Data
+dataRef :: Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.Data
+dataRef x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ref"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the repeated variant of hydra.scala.syntax.Data
+dataRepeated :: Typed.TypedTerm Syntax.RepeatedData -> Typed.TypedTerm Syntax.Data
+dataRepeated x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "repeated"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the return variant of hydra.scala.syntax.Data
+dataReturn :: Typed.TypedTerm Syntax.ReturnData -> Typed.TypedTerm Syntax.Data
+dataReturn x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "return"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the throw variant of hydra.scala.syntax.Data
+dataThrow :: Typed.TypedTerm Syntax.ThrowData -> Typed.TypedTerm Syntax.Data
+dataThrow x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "throw"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the try variant of hydra.scala.syntax.Data
+dataTry :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm Syntax.Data
+dataTry x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "try"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the tryWithHandler variant of hydra.scala.syntax.Data
+dataTryWithHandler :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data
+dataTryWithHandler x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "tryWithHandler"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the tuple variant of hydra.scala.syntax.Data
+dataTuple :: Typed.TypedTerm Syntax.TupleData -> Typed.TypedTerm Syntax.Data
+dataTuple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "tuple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the while variant of hydra.scala.syntax.Data
+dataWhile :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data
+dataWhile x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "while"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the def variant of hydra.scala.syntax.Decl
+declDef :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.Decl
+declDef x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "def"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the given variant of hydra.scala.syntax.Decl
+declGiven :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.Decl
+declGiven x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "given"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.scala.syntax.Decl
+declType :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.Decl
+declType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the val variant of hydra.scala.syntax.Decl
+declVal :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm Syntax.Decl
+declVal x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "val"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the var variant of hydra.scala.syntax.Decl
+declVar :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm Syntax.Decl
+declVar x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "var"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.DefDecl
+defDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.DefDecl
+defDecl mods name tparams paramss decltpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm paramss)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)}]}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.DefDecl
+defDeclDecltpe :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.Type
+defDeclDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.DefDecl
+defDeclMods :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [Syntax.Mod]
+defDeclMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.DefDecl
+defDeclName :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.NameData
+defDeclName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the paramss field of hydra.scala.syntax.DefDecl
+defDeclParamss :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [[Syntax.ParamData]]
+defDeclParamss x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+        Core.projectionFieldName = (Core.Name "paramss")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.DefDecl
+defDeclTparams :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [Syntax.ParamType]
+defDeclTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.DefDecl
+defDeclWithDecltpe :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.DefDecl
+defDeclWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.DefDecl
+defDeclWithMods :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.DefDecl
+defDeclWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.DefDecl
+defDeclWithName :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.DefDecl
+defDeclWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the paramss field of hydra.scala.syntax.DefDecl
+defDeclWithParamss :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.DefDecl
+defDeclWithParamss original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.DefDecl
+defDeclWithTparams :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.DefDecl
+defDeclWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.DefDefn
+defDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DefDefn
+defDefn mods name tparams paramss decltpe body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm paramss)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.DefDefn
+defDefnBody :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.Data
+defDefnBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.DefDefn
+defDefnDecltpe :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm (Maybe Syntax.Type)
+defDefnDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.DefDefn
+defDefnMods :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [Syntax.Mod]
+defDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.DefDefn
+defDefnName :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.NameData
+defDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the paramss field of hydra.scala.syntax.DefDefn
+defDefnParamss :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [[Syntax.ParamData]]
+defDefnParamss x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+        Core.projectionFieldName = (Core.Name "paramss")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.DefDefn
+defDefnTparams :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [Syntax.ParamType]
+defDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.DefDefn
+defDefnWithBody :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DefDefn
+defDefnWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.DefDefn
+defDefnWithDecltpe :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.DefDefn
+defDefnWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.DefDefn
+defDefnWithMods :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.DefDefn
+defDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.DefDefn
+defDefnWithName :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.DefDefn
+defDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the paramss field of hydra.scala.syntax.DefDefn
+defDefnWithParamss :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.DefDefn
+defDefnWithParamss original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.DefDefn
+defDefnWithTparams :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.DefDefn
+defDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.DefDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the class variant of hydra.scala.syntax.Defn
+defnClass :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.Defn
+defnClass x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "class"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the def variant of hydra.scala.syntax.Defn
+defnDef :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.Defn
+defnDef x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "def"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the enum variant of hydra.scala.syntax.Defn
+defnEnum :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.Defn
+defnEnum x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "enum"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the enumCase variant of hydra.scala.syntax.Defn
+defnEnumCase :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.Defn
+defnEnumCase x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "enumCase"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the extensionGroup variant of hydra.scala.syntax.Defn
+defnExtensionGroup :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm Syntax.Defn
+defnExtensionGroup x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "extensionGroup"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the given variant of hydra.scala.syntax.Defn
+defnGiven :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Defn
+defnGiven x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "given"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the givenAlias variant of hydra.scala.syntax.Defn
+defnGivenAlias :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Defn
+defnGivenAlias x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "givenAlias"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the object variant of hydra.scala.syntax.Defn
+defnObject :: Typed.TypedTerm Syntax.ObjectDefn -> Typed.TypedTerm Syntax.Defn
+defnObject x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "object"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the repeatedEnumCase variant of hydra.scala.syntax.Defn
+defnRepeatedEnumCase :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm Syntax.Defn
+defnRepeatedEnumCase x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "repeatedEnumCase"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the trait variant of hydra.scala.syntax.Defn
+defnTrait :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.Defn
+defnTrait x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "trait"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.scala.syntax.Defn
+defnType :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.Defn
+defnType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the val variant of hydra.scala.syntax.Defn
+defnVal :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm Syntax.Defn
+defnVal x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "val"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the var variant of hydra.scala.syntax.Defn
+defnVar :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm Syntax.Defn
+defnVar x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "var"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.DoData
+doData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DoData
+doData body expr =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DoData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.DoData
+doDataBody :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data
+doDataBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DoData"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.DoData
+doDataExpr :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data
+doDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DoData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.DoData
+doDataWithBody :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DoData
+doDataWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DoData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DoData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.DoData
+doDataWithExpr :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DoData
+doDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.DoData"),
+      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.scala.syntax.DoData"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.EndMarkerData
+endMarkerData :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.EndMarkerData
+endMarkerData name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EndMarkerData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.EndMarkerData
+endMarkerDataName :: Typed.TypedTerm Syntax.EndMarkerData -> Typed.TypedTerm Syntax.NameData
+endMarkerDataName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EndMarkerData"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.EndMarkerData
+endMarkerDataWithName :: Typed.TypedTerm Syntax.EndMarkerData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.EndMarkerData
+endMarkerDataWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EndMarkerData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.EnumCaseDefn
+enumCaseDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [Syntax.Init] -> Typed.TypedTerm Syntax.EnumCaseDefn
+enumCaseDefn mods name tparams ctor inits =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Typed.unTypedTerm ctor)},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Typed.unTypedTerm inits)}]}))
+
+-- | DSL accessor for the ctor field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnCtor :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.PrimaryCtor
+enumCaseDefnCtor x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+        Core.projectionFieldName = (Core.Name "ctor")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the inits field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnInits :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.Init]
+enumCaseDefnInits x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+        Core.projectionFieldName = (Core.Name "inits")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnMods :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.Mod]
+enumCaseDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnName :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.NameData
+enumCaseDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnTparams :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.ParamType]
+enumCaseDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the ctor field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnWithCtor :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.EnumCaseDefn
+enumCaseDefnWithCtor original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "inits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the inits field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnWithInits :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.Init] -> Typed.TypedTerm Syntax.EnumCaseDefn
+enumCaseDefnWithInits original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnWithMods :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.EnumCaseDefn
+enumCaseDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "inits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnWithName :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.EnumCaseDefn
+enumCaseDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "inits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.EnumCaseDefn
+enumCaseDefnWithTparams :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.EnumCaseDefn
+enumCaseDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "inits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.EnumDefn
+enumDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.EnumDefn
+enumDefn mods name tparams ctor template =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Typed.unTypedTerm ctor)},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Typed.unTypedTerm template)}]}))
+
+-- | DSL accessor for the ctor field of hydra.scala.syntax.EnumDefn
+enumDefnCtor :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.PrimaryCtor
+enumDefnCtor x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+        Core.projectionFieldName = (Core.Name "ctor")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.EnumDefn
+enumDefnMods :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm [Syntax.Mod]
+enumDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.EnumDefn
+enumDefnName :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.NameType
+enumDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the template field of hydra.scala.syntax.EnumDefn
+enumDefnTemplate :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.Template
+enumDefnTemplate x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+        Core.projectionFieldName = (Core.Name "template")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.EnumDefn
+enumDefnTparams :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm [Syntax.ParamType]
+enumDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the ctor field of hydra.scala.syntax.EnumDefn
+enumDefnWithCtor :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.EnumDefn
+enumDefnWithCtor original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.EnumDefn
+enumDefnWithMods :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.EnumDefn
+enumDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.EnumDefn
+enumDefnWithName :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.EnumDefn
+enumDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the template field of hydra.scala.syntax.EnumDefn
+enumDefnWithTemplate :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.EnumDefn
+enumDefnWithTemplate original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.EnumDefn
+enumDefnWithTparams :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.EnumDefn
+enumDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the caseGenerator variant of hydra.scala.syntax.Enumerator
+enumeratorCaseGenerator :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Enumerator
+enumeratorCaseGenerator x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Enumerator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "caseGenerator"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the generator variant of hydra.scala.syntax.Enumerator
+enumeratorGenerator :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Enumerator
+enumeratorGenerator x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Enumerator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "generator"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the guard variant of hydra.scala.syntax.Enumerator
+enumeratorGuard :: Typed.TypedTerm Syntax.GuardEnumerator -> Typed.TypedTerm Syntax.Enumerator
+enumeratorGuard x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Enumerator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "guard"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the val variant of hydra.scala.syntax.Enumerator
+enumeratorVal :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Enumerator
+enumeratorVal x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Enumerator"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "val"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.EtaData
+etaData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.EtaData
+etaData expr =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EtaData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)}]}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.EtaData
+etaDataExpr :: Typed.TypedTerm Syntax.EtaData -> Typed.TypedTerm Syntax.Data
+etaDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EtaData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.EtaData
+etaDataWithExpr :: Typed.TypedTerm Syntax.EtaData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.EtaData
+etaDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.EtaData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ExistentialType
+existentialType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.ExistentialType
+existentialType tpe stats =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm stats)}]}))
+
+-- | DSL accessor for the stats field of hydra.scala.syntax.ExistentialType
+existentialTypeStats :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm [Syntax.Stat]
+existentialTypeStats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),
+        Core.projectionFieldName = (Core.Name "stats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.ExistentialType
+existentialTypeTpe :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm Syntax.Type
+existentialTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the stats field of hydra.scala.syntax.ExistentialType
+existentialTypeWithStats :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.ExistentialType
+existentialTypeWithStats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.ExistentialType
+existentialTypeWithTpe :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ExistentialType
+existentialTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.Export
+export :: Typed.TypedTerm [Syntax.Importer] -> Typed.TypedTerm Syntax.Export
+export importers =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Export"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "importers"),
+          Core.fieldTerm = (Typed.unTypedTerm importers)}]}))
+
+-- | DSL accessor for the importers field of hydra.scala.syntax.Export
+exportImporters :: Typed.TypedTerm Syntax.Export -> Typed.TypedTerm [Syntax.Importer]
+exportImporters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Export"),
+        Core.projectionFieldName = (Core.Name "importers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the importers field of hydra.scala.syntax.Export
+exportWithImporters :: Typed.TypedTerm Syntax.Export -> Typed.TypedTerm [Syntax.Importer] -> Typed.TypedTerm Syntax.Export
+exportWithImporters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Export"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "importers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ExtensionGroupDefn
+extensionGroupDefn :: Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Stat -> Typed.TypedTerm Syntax.ExtensionGroupDefn
+extensionGroupDefn tparams parmss body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parmss"),
+          Core.fieldTerm = (Typed.unTypedTerm parmss)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.ExtensionGroupDefn
+extensionGroupDefnBody :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm Syntax.Stat
+extensionGroupDefnBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parmss field of hydra.scala.syntax.ExtensionGroupDefn
+extensionGroupDefnParmss :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm [[Syntax.ParamData]]
+extensionGroupDefnParmss x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+        Core.projectionFieldName = (Core.Name "parmss")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.ExtensionGroupDefn
+extensionGroupDefnTparams :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm [Syntax.ParamType]
+extensionGroupDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.ExtensionGroupDefn
+extensionGroupDefnWithBody :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm Syntax.Stat -> Typed.TypedTerm Syntax.ExtensionGroupDefn
+extensionGroupDefnWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parmss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+              Core.projectionFieldName = (Core.Name "parmss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the parmss field of hydra.scala.syntax.ExtensionGroupDefn
+extensionGroupDefnWithParmss :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.ExtensionGroupDefn
+extensionGroupDefnWithParmss original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parmss"),
+          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.scala.syntax.ExtensionGroupDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.ExtensionGroupDefn
+extensionGroupDefnWithTparams :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.ExtensionGroupDefn
+extensionGroupDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parmss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),
+              Core.projectionFieldName = (Core.Name "parmss")})),
+            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.scala.syntax.ExtensionGroupDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ExtractInfixPat
+extractInfixPat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ExtractInfixPat
+extractInfixPat lhs op rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lhs"),
+          Core.fieldTerm = (Typed.unTypedTerm lhs)},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm op)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the lhs field of hydra.scala.syntax.ExtractInfixPat
+extractInfixPatLhs :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.Pat
+extractInfixPatLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the op field of hydra.scala.syntax.ExtractInfixPat
+extractInfixPatOp :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.NameData
+extractInfixPatOp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+        Core.projectionFieldName = (Core.Name "op")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.ExtractInfixPat
+extractInfixPatRhs :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm [Syntax.Pat]
+extractInfixPatRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.ExtractInfixPat
+extractInfixPatWithLhs :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.ExtractInfixPat
+extractInfixPatWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+      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.scala.syntax.ExtractInfixPat"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the op field of hydra.scala.syntax.ExtractInfixPat
+extractInfixPatWithOp :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ExtractInfixPat
+extractInfixPatWithOp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+      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.scala.syntax.ExtractInfixPat"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "op"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.ExtractInfixPat
+extractInfixPatWithRhs :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ExtractInfixPat
+extractInfixPatWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),
+      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.scala.syntax.ExtractInfixPat"),
+              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.scala.syntax.ExtractInfixPat"),
+              Core.projectionFieldName = (Core.Name "op")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ExtractPat
+extractPat :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ExtractPat
+extractPat fun args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Typed.unTypedTerm fun)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.ExtractPat
+extractPatArgs :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm [Syntax.Pat]
+extractPatArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the fun field of hydra.scala.syntax.ExtractPat
+extractPatFun :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm Syntax.Data
+extractPatFun x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),
+        Core.projectionFieldName = (Core.Name "fun")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.ExtractPat
+extractPatWithArgs :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ExtractPat
+extractPatWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),
+              Core.projectionFieldName = (Core.Name "fun")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the fun field of hydra.scala.syntax.ExtractPat
+extractPatWithFun :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ExtractPat
+extractPatWithFun original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "fun"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ForData
+forData :: Typed.TypedTerm [Syntax.Enumerator] -> Typed.TypedTerm Syntax.ForData
+forData enums =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ForData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "enums"),
+          Core.fieldTerm = (Typed.unTypedTerm enums)}]}))
+
+-- | DSL accessor for the enums field of hydra.scala.syntax.ForData
+forDataEnums :: Typed.TypedTerm Syntax.ForData -> Typed.TypedTerm [Syntax.Enumerator]
+forDataEnums x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ForData"),
+        Core.projectionFieldName = (Core.Name "enums")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the enums field of hydra.scala.syntax.ForData
+forDataWithEnums :: Typed.TypedTerm Syntax.ForData -> Typed.TypedTerm [Syntax.Enumerator] -> Typed.TypedTerm Syntax.ForData
+forDataWithEnums original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ForData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "enums"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ForYieldData
+forYieldData :: Typed.TypedTerm [Syntax.Enumerator] -> Typed.TypedTerm Syntax.ForYieldData
+forYieldData enums =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ForYieldData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "enums"),
+          Core.fieldTerm = (Typed.unTypedTerm enums)}]}))
+
+-- | DSL accessor for the enums field of hydra.scala.syntax.ForYieldData
+forYieldDataEnums :: Typed.TypedTerm Syntax.ForYieldData -> Typed.TypedTerm [Syntax.Enumerator]
+forYieldDataEnums x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ForYieldData"),
+        Core.projectionFieldName = (Core.Name "enums")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the enums field of hydra.scala.syntax.ForYieldData
+forYieldDataWithEnums :: Typed.TypedTerm Syntax.ForYieldData -> Typed.TypedTerm [Syntax.Enumerator] -> Typed.TypedTerm Syntax.ForYieldData
+forYieldDataWithEnums original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ForYieldData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "enums"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.FunctionData
+functionData :: Typed.TypedTerm [Syntax.ParamData] -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.FunctionData
+functionData params body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm params)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.FunctionData
+functionDataBody :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm Syntax.Data
+functionDataBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the params field of hydra.scala.syntax.FunctionData
+functionDataParams :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm [Syntax.ParamData]
+functionDataParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),
+        Core.projectionFieldName = (Core.Name "params")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.FunctionData
+functionDataWithBody :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.FunctionData
+functionDataWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the params field of hydra.scala.syntax.FunctionData
+functionDataWithParams :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm [Syntax.ParamData] -> Typed.TypedTerm Syntax.FunctionData
+functionDataWithParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          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.scala.syntax.FunctionData"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.FunctionType
+functionType :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType
+functionType params res =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm params)},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Typed.unTypedTerm res)}]}))
+
+-- | DSL accessor for the params field of hydra.scala.syntax.FunctionType
+functionTypeParams :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm [Syntax.Type]
+functionTypeParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),
+        Core.projectionFieldName = (Core.Name "params")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the res field of hydra.scala.syntax.FunctionType
+functionTypeRes :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type
+functionTypeRes x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),
+        Core.projectionFieldName = (Core.Name "res")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the params field of hydra.scala.syntax.FunctionType
+functionTypeWithParams :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.FunctionType
+functionTypeWithParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),
+              Core.projectionFieldName = (Core.Name "res")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the res field of hydra.scala.syntax.FunctionType
+functionTypeWithRes :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType
+functionTypeWithRes original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.GeneratorEnumerator
+generatorEnumerator :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GeneratorEnumerator
+generatorEnumerator pat rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Typed.unTypedTerm pat)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the pat field of hydra.scala.syntax.GeneratorEnumerator
+generatorEnumeratorPat :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Pat
+generatorEnumeratorPat x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),
+        Core.projectionFieldName = (Core.Name "pat")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.GeneratorEnumerator
+generatorEnumeratorRhs :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Data
+generatorEnumeratorRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the pat field of hydra.scala.syntax.GeneratorEnumerator
+generatorEnumeratorWithPat :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.GeneratorEnumerator
+generatorEnumeratorWithPat original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          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.scala.syntax.GeneratorEnumerator"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.GeneratorEnumerator
+generatorEnumeratorWithRhs :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GeneratorEnumerator
+generatorEnumeratorWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),
+              Core.projectionFieldName = (Core.Name "pat")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.GivenAliasDefn
+givenAliasDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.ParamType]] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GivenAliasDefn
+givenAliasDefn mods name tparams sparams decltpe body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Typed.unTypedTerm sparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnBody :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Data
+givenAliasDefnBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnDecltpe :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Type
+givenAliasDefnDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnMods :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [Syntax.Mod]
+givenAliasDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnName :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Name
+givenAliasDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the sparams field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnSparams :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [[Syntax.ParamData]]
+givenAliasDefnSparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+        Core.projectionFieldName = (Core.Name "sparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnTparams :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [[Syntax.ParamType]]
+givenAliasDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnWithBody :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GivenAliasDefn
+givenAliasDefnWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnWithDecltpe :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenAliasDefn
+givenAliasDefnWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnWithMods :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.GivenAliasDefn
+givenAliasDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnWithName :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.GivenAliasDefn
+givenAliasDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the sparams field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnWithSparams :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.GivenAliasDefn
+givenAliasDefnWithSparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.GivenAliasDefn
+givenAliasDefnWithTparams :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [[Syntax.ParamType]] -> Typed.TypedTerm Syntax.GivenAliasDefn
+givenAliasDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.GivenAliasDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.GivenDecl
+givenDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenDecl
+givenDecl mods name tparams sparams decltpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Typed.unTypedTerm sparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)}]}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.GivenDecl
+givenDeclDecltpe :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.Type
+givenDeclDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.GivenDecl
+givenDeclMods :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [Syntax.Mod]
+givenDeclMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.GivenDecl
+givenDeclName :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.NameData
+givenDeclName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the sparams field of hydra.scala.syntax.GivenDecl
+givenDeclSparams :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [[Syntax.ParamData]]
+givenDeclSparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+        Core.projectionFieldName = (Core.Name "sparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.GivenDecl
+givenDeclTparams :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [Syntax.ParamType]
+givenDeclTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.GivenDecl
+givenDeclWithDecltpe :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenDecl
+givenDeclWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.GivenDecl
+givenDeclWithMods :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.GivenDecl
+givenDeclWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.GivenDecl
+givenDeclWithName :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.GivenDecl
+givenDeclWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the sparams field of hydra.scala.syntax.GivenDecl
+givenDeclWithSparams :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.GivenDecl
+givenDeclWithSparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.GivenDecl
+givenDeclWithTparams :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.GivenDecl
+givenDeclWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.GivenDefn
+givenDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.ParamType]] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.GivenDefn
+givenDefn mods name tparams sparams templ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Typed.unTypedTerm sparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "templ"),
+          Core.fieldTerm = (Typed.unTypedTerm templ)}]}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.GivenDefn
+givenDefnMods :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [Syntax.Mod]
+givenDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.GivenDefn
+givenDefnName :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Name
+givenDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the sparams field of hydra.scala.syntax.GivenDefn
+givenDefnSparams :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [[Syntax.ParamData]]
+givenDefnSparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+        Core.projectionFieldName = (Core.Name "sparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the templ field of hydra.scala.syntax.GivenDefn
+givenDefnTempl :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Template
+givenDefnTempl x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+        Core.projectionFieldName = (Core.Name "templ")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.GivenDefn
+givenDefnTparams :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [[Syntax.ParamType]]
+givenDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.GivenDefn
+givenDefnWithMods :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.GivenDefn
+givenDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "templ"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "templ")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.GivenDefn
+givenDefnWithName :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.GivenDefn
+givenDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "templ"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "templ")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the sparams field of hydra.scala.syntax.GivenDefn
+givenDefnWithSparams :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.GivenDefn
+givenDefnWithSparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "templ"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "templ")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the templ field of hydra.scala.syntax.GivenDefn
+givenDefnWithTempl :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.GivenDefn
+givenDefnWithTempl original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "templ"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.GivenDefn
+givenDefnWithTparams :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [[Syntax.ParamType]] -> Typed.TypedTerm Syntax.GivenDefn
+givenDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "sparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "sparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "templ"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),
+              Core.projectionFieldName = (Core.Name "templ")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.GivenImportee
+givenImportee :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenImportee
+givenImportee tpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenImportee"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.GivenImportee
+givenImporteeTpe :: Typed.TypedTerm Syntax.GivenImportee -> Typed.TypedTerm Syntax.Type
+givenImporteeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenImportee"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.GivenImportee
+givenImporteeWithTpe :: Typed.TypedTerm Syntax.GivenImportee -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenImportee
+givenImporteeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenImportee"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.GivenPat
+givenPat :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenPat
+givenPat tpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.GivenPat
+givenPatTpe :: Typed.TypedTerm Syntax.GivenPat -> Typed.TypedTerm Syntax.Type
+givenPatTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenPat"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.GivenPat
+givenPatWithTpe :: Typed.TypedTerm Syntax.GivenPat -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenPat
+givenPatWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.GuardEnumerator
+guardEnumerator :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GuardEnumerator
+guardEnumerator cond =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GuardEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)}]}))
+
+-- | DSL accessor for the cond field of hydra.scala.syntax.GuardEnumerator
+guardEnumeratorCond :: Typed.TypedTerm Syntax.GuardEnumerator -> Typed.TypedTerm Syntax.Data
+guardEnumeratorCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GuardEnumerator"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cond field of hydra.scala.syntax.GuardEnumerator
+guardEnumeratorWithCond :: Typed.TypedTerm Syntax.GuardEnumerator -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GuardEnumerator
+guardEnumeratorWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.GuardEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.IfData
+ifData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.IfData
+ifData cond thenp elsep =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm cond)},
+        Core.Field {
+          Core.fieldName = (Core.Name "thenp"),
+          Core.fieldTerm = (Typed.unTypedTerm thenp)},
+        Core.Field {
+          Core.fieldName = (Core.Name "elsep"),
+          Core.fieldTerm = (Typed.unTypedTerm elsep)}]}))
+
+-- | DSL accessor for the cond field of hydra.scala.syntax.IfData
+ifDataCond :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data
+ifDataCond x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+        Core.projectionFieldName = (Core.Name "cond")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the elsep field of hydra.scala.syntax.IfData
+ifDataElsep :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data
+ifDataElsep x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+        Core.projectionFieldName = (Core.Name "elsep")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the thenp field of hydra.scala.syntax.IfData
+ifDataThenp :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data
+ifDataThenp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+        Core.projectionFieldName = (Core.Name "thenp")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cond field of hydra.scala.syntax.IfData
+ifDataWithCond :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.IfData
+ifDataWithCond original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cond"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "thenp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+              Core.projectionFieldName = (Core.Name "thenp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "elsep"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+              Core.projectionFieldName = (Core.Name "elsep")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the elsep field of hydra.scala.syntax.IfData
+ifDataWithElsep :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.IfData
+ifDataWithElsep original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+      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.scala.syntax.IfData"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thenp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+              Core.projectionFieldName = (Core.Name "thenp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "elsep"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the thenp field of hydra.scala.syntax.IfData
+ifDataWithThenp :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.IfData
+ifDataWithThenp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+      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.scala.syntax.IfData"),
+              Core.projectionFieldName = (Core.Name "cond")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "thenp"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "elsep"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),
+              Core.projectionFieldName = (Core.Name "elsep")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ImplicitFunctionType
+implicitFunctionType :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ImplicitFunctionType
+implicitFunctionType params res =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm params)},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Typed.unTypedTerm res)}]}))
+
+-- | DSL accessor for the params field of hydra.scala.syntax.ImplicitFunctionType
+implicitFunctionTypeParams :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm [Syntax.Type]
+implicitFunctionTypeParams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),
+        Core.projectionFieldName = (Core.Name "params")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the res field of hydra.scala.syntax.ImplicitFunctionType
+implicitFunctionTypeRes :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm Syntax.Type
+implicitFunctionTypeRes x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),
+        Core.projectionFieldName = (Core.Name "res")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the params field of hydra.scala.syntax.ImplicitFunctionType
+implicitFunctionTypeWithParams :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ImplicitFunctionType
+implicitFunctionTypeWithParams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),
+              Core.projectionFieldName = (Core.Name "res")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the res field of hydra.scala.syntax.ImplicitFunctionType
+implicitFunctionTypeWithRes :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ImplicitFunctionType
+implicitFunctionTypeWithRes original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "params"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),
+              Core.projectionFieldName = (Core.Name "params")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "res"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.Import
+import_ :: Typed.TypedTerm [Syntax.Importer] -> Typed.TypedTerm Syntax.Import
+import_ importers =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Import"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "importers"),
+          Core.fieldTerm = (Typed.unTypedTerm importers)}]}))
+
+-- | DSL injection for the export variant of hydra.scala.syntax.ImportExportStat
+importExportStatExport :: Typed.TypedTerm Syntax.Export -> Typed.TypedTerm Syntax.ImportExportStat
+importExportStatExport x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.ImportExportStat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "export"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the import variant of hydra.scala.syntax.ImportExportStat
+importExportStatImport :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm Syntax.ImportExportStat
+importExportStatImport x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.ImportExportStat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "import"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL accessor for the importers field of hydra.scala.syntax.Import
+importImporters :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm [Syntax.Importer]
+importImporters x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Import"),
+        Core.projectionFieldName = (Core.Name "importers")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the importers field of hydra.scala.syntax.Import
+importWithImporters :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm [Syntax.Importer] -> Typed.TypedTerm Syntax.Import
+importWithImporters original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Import"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "importers"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the given variant of hydra.scala.syntax.Importee
+importeeGiven :: Typed.TypedTerm Syntax.GivenImportee -> Typed.TypedTerm Syntax.Importee
+importeeGiven x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "given"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the givenAll variant of hydra.scala.syntax.Importee
+importeeGivenAll :: Typed.TypedTerm Syntax.Importee
+importeeGivenAll =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "givenAll"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the name variant of hydra.scala.syntax.Importee
+importeeName :: Typed.TypedTerm Syntax.NameImportee -> Typed.TypedTerm Syntax.Importee
+importeeName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the rename variant of hydra.scala.syntax.Importee
+importeeRename :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Importee
+importeeRename x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "rename"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the unimport variant of hydra.scala.syntax.Importee
+importeeUnimport :: Typed.TypedTerm Syntax.UnimportImportee -> Typed.TypedTerm Syntax.Importee
+importeeUnimport x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unimport"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the wildcard variant of hydra.scala.syntax.Importee
+importeeWildcard :: Typed.TypedTerm Syntax.Importee
+importeeWildcard =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "wildcard"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.scala.syntax.Importer
+importer :: Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm [Syntax.Importee] -> Typed.TypedTerm Syntax.Importer
+importer ref importees =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Importer"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Typed.unTypedTerm ref)},
+        Core.Field {
+          Core.fieldName = (Core.Name "importees"),
+          Core.fieldTerm = (Typed.unTypedTerm importees)}]}))
+
+-- | DSL accessor for the importees field of hydra.scala.syntax.Importer
+importerImportees :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm [Syntax.Importee]
+importerImportees x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Importer"),
+        Core.projectionFieldName = (Core.Name "importees")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the ref field of hydra.scala.syntax.Importer
+importerRef :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm Syntax.RefData
+importerRef x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Importer"),
+        Core.projectionFieldName = (Core.Name "ref")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the importees field of hydra.scala.syntax.Importer
+importerWithImportees :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm [Syntax.Importee] -> Typed.TypedTerm Syntax.Importer
+importerWithImportees original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Importer"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Importer"),
+              Core.projectionFieldName = (Core.Name "ref")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "importees"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the ref field of hydra.scala.syntax.Importer
+importerWithRef :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.Importer
+importerWithRef original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Importer"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "importees"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Importer"),
+              Core.projectionFieldName = (Core.Name "importees")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.Init
+init :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.Data]] -> Typed.TypedTerm Syntax.Init
+init tpe name argss =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Init"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "argss"),
+          Core.fieldTerm = (Typed.unTypedTerm argss)}]}))
+
+-- | DSL accessor for the argss field of hydra.scala.syntax.Init
+initArgss :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm [[Syntax.Data]]
+initArgss x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),
+        Core.projectionFieldName = (Core.Name "argss")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.Init
+initName :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Name
+initName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.Init
+initTpe :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Type
+initTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the argss field of hydra.scala.syntax.Init
+initWithArgss :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm [[Syntax.Data]] -> Typed.TypedTerm Syntax.Init
+initWithArgss original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Init"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            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.scala.syntax.Init"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "argss"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.Init
+initWithName :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Init
+initWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Init"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "argss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),
+              Core.projectionFieldName = (Core.Name "argss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.Init
+initWithTpe :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Init
+initWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Init"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          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.scala.syntax.Init"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "argss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),
+              Core.projectionFieldName = (Core.Name "argss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.InterpolateData
+interpolateData :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Lit] -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.InterpolateData
+interpolateData prefix parts args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "prefix"),
+          Core.fieldTerm = (Typed.unTypedTerm prefix)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parts"),
+          Core.fieldTerm = (Typed.unTypedTerm parts)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.InterpolateData
+interpolateDataArgs :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm [Syntax.Data]
+interpolateDataArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the parts field of hydra.scala.syntax.InterpolateData
+interpolateDataParts :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm [Syntax.Lit]
+interpolateDataParts x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+        Core.projectionFieldName = (Core.Name "parts")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the prefix field of hydra.scala.syntax.InterpolateData
+interpolateDataPrefix :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm Syntax.NameData
+interpolateDataPrefix x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+        Core.projectionFieldName = (Core.Name "prefix")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.InterpolateData
+interpolateDataWithArgs :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.InterpolateData
+interpolateDataWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "prefix"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+              Core.projectionFieldName = (Core.Name "prefix")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parts"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+              Core.projectionFieldName = (Core.Name "parts")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the parts field of hydra.scala.syntax.InterpolateData
+interpolateDataWithParts :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm [Syntax.Lit] -> Typed.TypedTerm Syntax.InterpolateData
+interpolateDataWithParts original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "prefix"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+              Core.projectionFieldName = (Core.Name "prefix")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parts"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the prefix field of hydra.scala.syntax.InterpolateData
+interpolateDataWithPrefix :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.InterpolateData
+interpolateDataWithPrefix original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "prefix"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parts"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+              Core.projectionFieldName = (Core.Name "parts")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),
+              Core.projectionFieldName = (Core.Name "args")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.InterpolatePat
+interpolatePat :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Lit] -> Typed.TypedTerm Syntax.InterpolatePat
+interpolatePat prefix parts =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "prefix"),
+          Core.fieldTerm = (Typed.unTypedTerm prefix)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parts"),
+          Core.fieldTerm = (Typed.unTypedTerm parts)}]}))
+
+-- | DSL accessor for the parts field of hydra.scala.syntax.InterpolatePat
+interpolatePatParts :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm [Syntax.Lit]
+interpolatePatParts x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),
+        Core.projectionFieldName = (Core.Name "parts")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the prefix field of hydra.scala.syntax.InterpolatePat
+interpolatePatPrefix :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm Syntax.NameData
+interpolatePatPrefix x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),
+        Core.projectionFieldName = (Core.Name "prefix")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the parts field of hydra.scala.syntax.InterpolatePat
+interpolatePatWithParts :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm [Syntax.Lit] -> Typed.TypedTerm Syntax.InterpolatePat
+interpolatePatWithParts original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "prefix"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),
+              Core.projectionFieldName = (Core.Name "prefix")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "parts"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the prefix field of hydra.scala.syntax.InterpolatePat
+interpolatePatWithPrefix :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.InterpolatePat
+interpolatePatWithPrefix original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "prefix"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "parts"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),
+              Core.projectionFieldName = (Core.Name "parts")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.LambdaType
+lambdaType :: Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LambdaType
+lambdaType tparams tpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.LambdaType
+lambdaTypeTparams :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm [Syntax.ParamType]
+lambdaTypeTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.LambdaType
+lambdaTypeTpe :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm Syntax.Type
+lambdaTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.LambdaType
+lambdaTypeWithTparams :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.LambdaType
+lambdaTypeWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.LambdaType
+lambdaTypeWithTpe :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LambdaType
+lambdaTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the boolean variant of hydra.scala.syntax.Lit
+litBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Lit
+litBoolean x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "boolean"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the byte variant of hydra.scala.syntax.Lit
+litByte :: Typed.TypedTerm I.Int8 -> Typed.TypedTerm Syntax.Lit
+litByte x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "byte"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the bytes variant of hydra.scala.syntax.Lit
+litBytes :: Typed.TypedTerm [Int] -> Typed.TypedTerm Syntax.Lit
+litBytes x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bytes"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the char variant of hydra.scala.syntax.Lit
+litChar :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.Lit
+litChar x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "char"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the double variant of hydra.scala.syntax.Lit
+litDouble :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.Lit
+litDouble x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "double"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the float variant of hydra.scala.syntax.Lit
+litFloat :: Typed.TypedTerm Float -> Typed.TypedTerm Syntax.Lit
+litFloat x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "float"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the int variant of hydra.scala.syntax.Lit
+litInt :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.Lit
+litInt x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "int"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the long variant of hydra.scala.syntax.Lit
+litLong :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Syntax.Lit
+litLong x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "long"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the null variant of hydra.scala.syntax.Lit
+litNull :: Typed.TypedTerm Syntax.Lit
+litNull =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "null"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the short variant of hydra.scala.syntax.Lit
+litShort :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Syntax.Lit
+litShort x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "short"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the string variant of hydra.scala.syntax.Lit
+litString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Lit
+litString x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "string"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the symbol variant of hydra.scala.syntax.Lit
+litSymbol :: Typed.TypedTerm Syntax.ScalaSymbol -> Typed.TypedTerm Syntax.Lit
+litSymbol x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "symbol"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the unit variant of hydra.scala.syntax.Lit
+litUnit :: Typed.TypedTerm Syntax.Lit
+litUnit =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "unit"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.scala.syntax.MatchData
+matchData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.MatchData
+matchData expr cases =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))
+
+-- | DSL accessor for the cases field of hydra.scala.syntax.MatchData
+matchDataCases :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm [Syntax.Case]
+matchDataCases x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchData"),
+        Core.projectionFieldName = (Core.Name "cases")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.MatchData
+matchDataExpr :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm Syntax.Data
+matchDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cases field of hydra.scala.syntax.MatchData
+matchDataWithCases :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.MatchData
+matchDataWithCases original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.MatchData
+matchDataWithExpr :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.MatchData
+matchDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchData"),
+              Core.projectionFieldName = (Core.Name "cases")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.MatchType
+matchType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.TypeCase] -> Typed.TypedTerm Syntax.MatchType
+matchType tpe cases =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))
+
+-- | DSL accessor for the cases field of hydra.scala.syntax.MatchType
+matchTypeCases :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm [Syntax.TypeCase]
+matchTypeCases x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchType"),
+        Core.projectionFieldName = (Core.Name "cases")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.MatchType
+matchTypeTpe :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm Syntax.Type
+matchTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cases field of hydra.scala.syntax.MatchType
+matchTypeWithCases :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm [Syntax.TypeCase] -> Typed.TypedTerm Syntax.MatchType
+matchTypeWithCases original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchType"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.MatchType
+matchTypeWithTpe :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MatchType
+matchTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchType"),
+              Core.projectionFieldName = (Core.Name "cases")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the self variant of hydra.scala.syntax.Member
+memberSelf :: Typed.TypedTerm Syntax.Self -> Typed.TypedTerm Syntax.Member
+memberSelf x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "self"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the term variant of hydra.scala.syntax.Member
+memberTerm :: Typed.TypedTerm Syntax.DataMember -> Typed.TypedTerm Syntax.Member
+memberTerm x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "term"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the termParam variant of hydra.scala.syntax.Member
+memberTermParam :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm Syntax.Member
+memberTermParam x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "termParam"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.scala.syntax.Member
+memberType :: Typed.TypedTerm Syntax.TypeMember -> Typed.TypedTerm Syntax.Member
+memberType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the typeParam variant of hydra.scala.syntax.Member
+memberTypeParam :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm Syntax.Member
+memberTypeParam x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typeParam"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.MethodType
+methodType :: Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MethodType
+methodType paramss tpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MethodType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm paramss)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))
+
+-- | DSL accessor for the paramss field of hydra.scala.syntax.MethodType
+methodTypeParamss :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm [[Syntax.ParamData]]
+methodTypeParamss x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MethodType"),
+        Core.projectionFieldName = (Core.Name "paramss")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.MethodType
+methodTypeTpe :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm Syntax.Type
+methodTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MethodType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the paramss field of hydra.scala.syntax.MethodType
+methodTypeWithParamss :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.MethodType
+methodTypeWithParamss original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MethodType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MethodType"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.MethodType
+methodTypeWithTpe :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MethodType
+methodTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.MethodType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MethodType"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the abstract variant of hydra.scala.syntax.Mod
+modAbstract :: Typed.TypedTerm Syntax.Mod
+modAbstract =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "abstract"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the annot variant of hydra.scala.syntax.Mod
+modAnnot :: Typed.TypedTerm Syntax.AnnotMod -> Typed.TypedTerm Syntax.Mod
+modAnnot x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annot"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the case variant of hydra.scala.syntax.Mod
+modCase :: Typed.TypedTerm Syntax.Mod
+modCase =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "case"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the contravariant variant of hydra.scala.syntax.Mod
+modContravariant :: Typed.TypedTerm Syntax.Mod
+modContravariant =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "contravariant"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the covariant variant of hydra.scala.syntax.Mod
+modCovariant :: Typed.TypedTerm Syntax.Mod
+modCovariant =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "covariant"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the final variant of hydra.scala.syntax.Mod
+modFinal :: Typed.TypedTerm Syntax.Mod
+modFinal =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "final"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the implicit variant of hydra.scala.syntax.Mod
+modImplicit :: Typed.TypedTerm Syntax.Mod
+modImplicit =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "implicit"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the infix variant of hydra.scala.syntax.Mod
+modInfix :: Typed.TypedTerm Syntax.Mod
+modInfix =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "infix"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the inline variant of hydra.scala.syntax.Mod
+modInline :: Typed.TypedTerm Syntax.Mod
+modInline =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "inline"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the lazy variant of hydra.scala.syntax.Mod
+modLazy :: Typed.TypedTerm Syntax.Mod
+modLazy =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lazy"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the opaque variant of hydra.scala.syntax.Mod
+modOpaque :: Typed.TypedTerm Syntax.Mod
+modOpaque =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "opaque"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the open variant of hydra.scala.syntax.Mod
+modOpen :: Typed.TypedTerm Syntax.Mod
+modOpen =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "open"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the override variant of hydra.scala.syntax.Mod
+modOverride :: Typed.TypedTerm Syntax.Mod
+modOverride =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "override"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the private variant of hydra.scala.syntax.Mod
+modPrivate :: Typed.TypedTerm Syntax.PrivateMod -> Typed.TypedTerm Syntax.Mod
+modPrivate x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "private"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the protected variant of hydra.scala.syntax.Mod
+modProtected :: Typed.TypedTerm Syntax.ProtectedMod -> Typed.TypedTerm Syntax.Mod
+modProtected x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "protected"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the sealed variant of hydra.scala.syntax.Mod
+modSealed :: Typed.TypedTerm Syntax.Mod
+modSealed =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "sealed"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the super variant of hydra.scala.syntax.Mod
+modSuper :: Typed.TypedTerm Syntax.Mod
+modSuper =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "super"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the transparent variant of hydra.scala.syntax.Mod
+modTransparent :: Typed.TypedTerm Syntax.Mod
+modTransparent =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "transparent"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the using variant of hydra.scala.syntax.Mod
+modUsing :: Typed.TypedTerm Syntax.Mod
+modUsing =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "using"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the valParam variant of hydra.scala.syntax.Mod
+modValParam :: Typed.TypedTerm Syntax.Mod
+modValParam =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "valParam"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the varParam variant of hydra.scala.syntax.Mod
+modVarParam :: Typed.TypedTerm Syntax.Mod
+modVarParam =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "varParam"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the anonymous variant of hydra.scala.syntax.Name
+nameAnonymous :: Typed.TypedTerm Syntax.Name
+nameAnonymous =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Name"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "anonymous"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.scala.syntax.NameData
+nameData :: Typed.TypedTerm Syntax.PredefString -> Typed.TypedTerm Syntax.NameData
+nameData value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the value field of hydra.scala.syntax.NameData
+nameDataValue :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.PredefString
+nameDataValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NameData"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the value field of hydra.scala.syntax.NameData
+nameDataWithValue :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.PredefString -> Typed.TypedTerm Syntax.NameData
+nameDataWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.NameImportee
+nameImportee :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.NameImportee
+nameImportee name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameImportee"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.NameImportee
+nameImporteeName :: Typed.TypedTerm Syntax.NameImportee -> Typed.TypedTerm Syntax.Name
+nameImporteeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NameImportee"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.NameImportee
+nameImporteeWithName :: Typed.TypedTerm Syntax.NameImportee -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.NameImportee
+nameImporteeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameImportee"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the indeterminate variant of hydra.scala.syntax.Name
+nameIndeterminate :: Typed.TypedTerm Syntax.PredefString -> Typed.TypedTerm Syntax.Name
+nameIndeterminate x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Name"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "indeterminate"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.NameType
+nameType :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.NameType
+nameType value =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))
+
+-- | DSL accessor for the value field of hydra.scala.syntax.NameType
+nameTypeValue :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm String
+nameTypeValue x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NameType"),
+        Core.projectionFieldName = (Core.Name "value")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the value field of hydra.scala.syntax.NameType
+nameTypeWithValue :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.NameType
+nameTypeWithValue original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "value"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the value variant of hydra.scala.syntax.Name
+nameValue :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Name
+nameValue x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Name"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "value"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.NewAnonymousData
+newAnonymousData :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.NewAnonymousData
+newAnonymousData templ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NewAnonymousData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "templ"),
+          Core.fieldTerm = (Typed.unTypedTerm templ)}]}))
+
+-- | DSL accessor for the templ field of hydra.scala.syntax.NewAnonymousData
+newAnonymousDataTempl :: Typed.TypedTerm Syntax.NewAnonymousData -> Typed.TypedTerm Syntax.Template
+newAnonymousDataTempl x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NewAnonymousData"),
+        Core.projectionFieldName = (Core.Name "templ")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the templ field of hydra.scala.syntax.NewAnonymousData
+newAnonymousDataWithTempl :: Typed.TypedTerm Syntax.NewAnonymousData -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.NewAnonymousData
+newAnonymousDataWithTempl original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NewAnonymousData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "templ"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.NewData
+newData :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.NewData
+newData init =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NewData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm init)}]}))
+
+-- | DSL accessor for the init field of hydra.scala.syntax.NewData
+newDataInit :: Typed.TypedTerm Syntax.NewData -> Typed.TypedTerm Syntax.Init
+newDataInit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NewData"),
+        Core.projectionFieldName = (Core.Name "init")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the init field of hydra.scala.syntax.NewData
+newDataWithInit :: Typed.TypedTerm Syntax.NewData -> Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.NewData
+newDataWithInit original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.NewData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ObjectDefn
+objectDefn :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ObjectDefn
+objectDefn name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.ObjectDefn
+objectDefnName :: Typed.TypedTerm Syntax.ObjectDefn -> Typed.TypedTerm Syntax.NameData
+objectDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.ObjectDefn
+objectDefnWithName :: Typed.TypedTerm Syntax.ObjectDefn -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ObjectDefn
+objectDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ObjectPkg
+objectPkg :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.ObjectPkg
+objectPkg mods name template =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Typed.unTypedTerm template)}]}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.ObjectPkg
+objectPkgMods :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm [Syntax.Mod]
+objectPkgMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.ObjectPkg
+objectPkgName :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.NameData
+objectPkgName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the template field of hydra.scala.syntax.ObjectPkg
+objectPkgTemplate :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.Template
+objectPkgTemplate x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+        Core.projectionFieldName = (Core.Name "template")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.ObjectPkg
+objectPkgWithMods :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ObjectPkg
+objectPkgWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.ObjectPkg"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.ObjectPkg
+objectPkgWithName :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ObjectPkg
+objectPkgWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the template field of hydra.scala.syntax.ObjectPkg
+objectPkgWithTemplate :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.ObjectPkg
+objectPkgWithTemplate original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ObjectPkg"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.OrType
+orType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OrType
+orType lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.OrType"),
+      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.scala.syntax.OrType
+orTypeLhs :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type
+orTypeLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.OrType"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.OrType
+orTypeRhs :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type
+orTypeRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.OrType"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.OrType
+orTypeWithLhs :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OrType
+orTypeWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.OrType"),
+      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.scala.syntax.OrType"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.OrType
+orTypeWithRhs :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OrType
+orTypeWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.OrType"),
+      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.scala.syntax.OrType"),
+              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.scala.syntax.ParamData
+paramData :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.ParamData
+paramData mods name decltpe default_ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.ParamData
+paramDataDecltpe :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm (Maybe Syntax.Type)
+paramDataDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the default field of hydra.scala.syntax.ParamData
+paramDataDefault :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm (Maybe Syntax.Data)
+paramDataDefault x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+        Core.projectionFieldName = (Core.Name "default")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.ParamData
+paramDataMods :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm [Syntax.Mod]
+paramDataMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.ParamData
+paramDataName :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm Syntax.Name
+paramDataName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.ParamData
+paramDataWithDecltpe :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.ParamData
+paramDataWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          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.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the default field of hydra.scala.syntax.ParamData
+paramDataWithDefault :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.ParamData
+paramDataWithDefault original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "default"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.ParamData
+paramDataWithMods :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ParamData
+paramDataWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.ParamData
+paramDataWithName :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ParamData
+paramDataWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            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.scala.syntax.ParamData"),
+              Core.projectionFieldName = (Core.Name "default")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ParamType
+paramType :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [Syntax.TypeBounds] -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ParamType
+paramType mods name tparams tbounds vbounds cbounds =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tbounds"),
+          Core.fieldTerm = (Typed.unTypedTerm tbounds)},
+        Core.Field {
+          Core.fieldName = (Core.Name "vbounds"),
+          Core.fieldTerm = (Typed.unTypedTerm vbounds)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cbounds"),
+          Core.fieldTerm = (Typed.unTypedTerm cbounds)}]}))
+
+-- | DSL accessor for the cbounds field of hydra.scala.syntax.ParamType
+paramTypeCbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Type]
+paramTypeCbounds x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+        Core.projectionFieldName = (Core.Name "cbounds")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.ParamType
+paramTypeMods :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Mod]
+paramTypeMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.ParamType
+paramTypeName :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm Syntax.Name
+paramTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tbounds field of hydra.scala.syntax.ParamType
+paramTypeTbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.TypeBounds]
+paramTypeTbounds x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+        Core.projectionFieldName = (Core.Name "tbounds")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.ParamType
+paramTypeTparams :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.ParamType]
+paramTypeTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the vbounds field of hydra.scala.syntax.ParamType
+paramTypeVbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Type]
+paramTypeVbounds x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+        Core.projectionFieldName = (Core.Name "vbounds")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cbounds field of hydra.scala.syntax.ParamType
+paramTypeWithCbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ParamType
+paramTypeWithCbounds original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "vbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "vbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cbounds"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.ParamType
+paramTypeWithMods :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ParamType
+paramTypeWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "vbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "vbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "cbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.ParamType
+paramTypeWithName :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ParamType
+paramTypeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "vbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "vbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "cbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tbounds field of hydra.scala.syntax.ParamType
+paramTypeWithTbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.TypeBounds] -> Typed.TypedTerm Syntax.ParamType
+paramTypeWithTbounds original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tbounds"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "vbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "vbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "cbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.ParamType
+paramTypeWithTparams :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.ParamType
+paramTypeWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "vbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "vbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "cbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the vbounds field of hydra.scala.syntax.ParamType
+paramTypeWithVbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ParamType
+paramTypeWithVbounds original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "tbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "vbounds"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cbounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),
+              Core.projectionFieldName = (Core.Name "cbounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.PartialFunctionData
+partialFunctionData :: Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.PartialFunctionData
+partialFunctionData cases =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PartialFunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))
+
+-- | DSL accessor for the cases field of hydra.scala.syntax.PartialFunctionData
+partialFunctionDataCases :: Typed.TypedTerm Syntax.PartialFunctionData -> Typed.TypedTerm [Syntax.Case]
+partialFunctionDataCases x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PartialFunctionData"),
+        Core.projectionFieldName = (Core.Name "cases")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cases field of hydra.scala.syntax.PartialFunctionData
+partialFunctionDataWithCases :: Typed.TypedTerm Syntax.PartialFunctionData -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.PartialFunctionData
+partialFunctionDataWithCases original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PartialFunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the alternative variant of hydra.scala.syntax.Pat
+patAlternative :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat
+patAlternative x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "alternative"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the bind variant of hydra.scala.syntax.Pat
+patBind :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat
+patBind x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bind"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the extract variant of hydra.scala.syntax.Pat
+patExtract :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm Syntax.Pat
+patExtract x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "extract"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the extractInfix variant of hydra.scala.syntax.Pat
+patExtractInfix :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.Pat
+patExtractInfix x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "extractInfix"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the given variant of hydra.scala.syntax.Pat
+patGiven :: Typed.TypedTerm Syntax.GivenPat -> Typed.TypedTerm Syntax.Pat
+patGiven x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "given"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the interpolate variant of hydra.scala.syntax.Pat
+patInterpolate :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm Syntax.Pat
+patInterpolate x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "interpolate"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the repeated variant of hydra.scala.syntax.Pat
+patRepeated :: Typed.TypedTerm Syntax.RepeatedPat -> Typed.TypedTerm Syntax.Pat
+patRepeated x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "repeated"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the seqWildcard variant of hydra.scala.syntax.Pat
+patSeqWildcard :: Typed.TypedTerm Syntax.Pat
+patSeqWildcard =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "seqWildcard"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL injection for the tuple variant of hydra.scala.syntax.Pat
+patTuple :: Typed.TypedTerm Syntax.TuplePat -> Typed.TypedTerm Syntax.Pat
+patTuple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "tuple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the typed variant of hydra.scala.syntax.Pat
+patTyped :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Pat
+patTyped x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typed"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the var variant of hydra.scala.syntax.Pat
+patVar :: Typed.TypedTerm Syntax.VarPat -> Typed.TypedTerm Syntax.Pat
+patVar x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "var"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the wildcard variant of hydra.scala.syntax.Pat
+patWildcard :: Typed.TypedTerm Syntax.Pat
+patWildcard =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "wildcard"),
+        Core.fieldTerm = Core.TermUnit}}))
+
+-- | DSL constructor for hydra.scala.syntax.Pkg
+pkg :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Pkg
+pkg name ref stats =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Typed.unTypedTerm ref)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm stats)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.Pkg
+pkgName :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.NameData
+pkgName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the ref field of hydra.scala.syntax.Pkg
+pkgRef :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.RefData
+pkgRef x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+        Core.projectionFieldName = (Core.Name "ref")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the stats field of hydra.scala.syntax.Pkg
+pkgStats :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm [Syntax.Stat]
+pkgStats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+        Core.projectionFieldName = (Core.Name "stats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.Pkg
+pkgWithName :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.Pkg
+pkgWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+              Core.projectionFieldName = (Core.Name "ref")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the ref field of hydra.scala.syntax.Pkg
+pkgWithRef :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.Pkg
+pkgWithRef original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+      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.scala.syntax.Pkg"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the stats field of hydra.scala.syntax.Pkg
+pkgWithStats :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Pkg
+pkgWithStats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+      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.scala.syntax.Pkg"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),
+              Core.projectionFieldName = (Core.Name "ref")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.PlaceholderType
+placeholderType :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.PlaceholderType
+placeholderType bounds =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PlaceholderType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Typed.unTypedTerm bounds)}]}))
+
+-- | DSL accessor for the bounds field of hydra.scala.syntax.PlaceholderType
+placeholderTypeBounds :: Typed.TypedTerm Syntax.PlaceholderType -> Typed.TypedTerm Syntax.TypeBounds
+placeholderTypeBounds x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PlaceholderType"),
+        Core.projectionFieldName = (Core.Name "bounds")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the bounds field of hydra.scala.syntax.PlaceholderType
+placeholderTypeWithBounds :: Typed.TypedTerm Syntax.PlaceholderType -> Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.PlaceholderType
+placeholderTypeWithBounds original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PlaceholderType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.PolyFunctionData
+polyFunctionData :: Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.PolyFunctionData
+polyFunctionData tparams body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.PolyFunctionData
+polyFunctionDataBody :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm Syntax.Data
+polyFunctionDataBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.PolyFunctionData
+polyFunctionDataTparams :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm [Syntax.ParamType]
+polyFunctionDataTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.PolyFunctionData
+polyFunctionDataWithBody :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.PolyFunctionData
+polyFunctionDataWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.PolyFunctionData
+polyFunctionDataWithTparams :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PolyFunctionData
+polyFunctionDataWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          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.scala.syntax.PolyFunctionData"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.PolyFunctionType
+polyFunctionType :: Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.PolyFunctionType
+polyFunctionType tparams tpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.PolyFunctionType
+polyFunctionTypeTparams :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm [Syntax.ParamType]
+polyFunctionTypeTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.PolyFunctionType
+polyFunctionTypeTpe :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm Syntax.Type
+polyFunctionTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.PolyFunctionType
+polyFunctionTypeWithTparams :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PolyFunctionType
+polyFunctionTypeWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.PolyFunctionType
+polyFunctionTypeWithTpe :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.PolyFunctionType
+polyFunctionTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.scala.syntax.PredefString wrapper
+predefString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.PredefString
+predefString x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.PredefString"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.scala.syntax.PrimaryCtor
+primaryCtor :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.PrimaryCtor
+primaryCtor mods name paramss =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm paramss)}]}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.PrimaryCtor
+primaryCtorMods :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [Syntax.Mod]
+primaryCtorMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.PrimaryCtor
+primaryCtorName :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Name
+primaryCtorName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the paramss field of hydra.scala.syntax.PrimaryCtor
+primaryCtorParamss :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [[Syntax.ParamData]]
+primaryCtorParamss x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+        Core.projectionFieldName = (Core.Name "paramss")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.PrimaryCtor
+primaryCtorWithMods :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.PrimaryCtor
+primaryCtorWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.PrimaryCtor"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.PrimaryCtor
+primaryCtorWithName :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PrimaryCtor
+primaryCtorWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the paramss field of hydra.scala.syntax.PrimaryCtor
+primaryCtorWithParamss :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.PrimaryCtor
+primaryCtorWithParamss original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.PrimaryCtor"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.PrivateMod
+privateMod :: Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.PrivateMod
+privateMod within =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrivateMod"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "within"),
+          Core.fieldTerm = (Typed.unTypedTerm within)}]}))
+
+-- | DSL updater for the within field of hydra.scala.syntax.PrivateMod
+privateModWithWithin :: Typed.TypedTerm Syntax.PrivateMod -> Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.PrivateMod
+privateModWithWithin original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrivateMod"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "within"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL accessor for the within field of hydra.scala.syntax.PrivateMod
+privateModWithin :: Typed.TypedTerm Syntax.PrivateMod -> Typed.TypedTerm Syntax.Ref
+privateModWithin x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrivateMod"),
+        Core.projectionFieldName = (Core.Name "within")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.scala.syntax.ProjectType
+projectType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.ProjectType
+projectType qual name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          Core.fieldTerm = (Typed.unTypedTerm qual)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.ProjectType
+projectTypeName :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.NameType
+projectTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the qual field of hydra.scala.syntax.ProjectType
+projectTypeQual :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.Type
+projectTypeQual x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),
+        Core.projectionFieldName = (Core.Name "qual")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.ProjectType
+projectTypeWithName :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.ProjectType
+projectTypeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),
+              Core.projectionFieldName = (Core.Name "qual")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the qual field of hydra.scala.syntax.ProjectType
+projectTypeWithQual :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ProjectType
+projectTypeWithQual original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          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.scala.syntax.ProjectType"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ProtectedMod
+protectedMod :: Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.ProtectedMod
+protectedMod within =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProtectedMod"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "within"),
+          Core.fieldTerm = (Typed.unTypedTerm within)}]}))
+
+-- | DSL updater for the within field of hydra.scala.syntax.ProtectedMod
+protectedModWithWithin :: Typed.TypedTerm Syntax.ProtectedMod -> Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.ProtectedMod
+protectedModWithWithin original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProtectedMod"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "within"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL accessor for the within field of hydra.scala.syntax.ProtectedMod
+protectedModWithin :: Typed.TypedTerm Syntax.ProtectedMod -> Typed.TypedTerm Syntax.Ref
+protectedModWithin x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProtectedMod"),
+        Core.projectionFieldName = (Core.Name "within")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL injection for the anonymous variant of hydra.scala.syntax.RefData
+refDataAnonymous :: Typed.TypedTerm Syntax.AnonymousData -> Typed.TypedTerm Syntax.RefData
+refDataAnonymous x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "anonymous"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the applyUnary variant of hydra.scala.syntax.RefData
+refDataApplyUnary :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.RefData
+refDataApplyUnary x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "applyUnary"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the name variant of hydra.scala.syntax.RefData
+refDataName :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.RefData
+refDataName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the select variant of hydra.scala.syntax.RefData
+refDataSelect :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.RefData
+refDataSelect x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "select"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the super variant of hydra.scala.syntax.RefData
+refDataSuper :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.RefData
+refDataSuper x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "super"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the this variant of hydra.scala.syntax.RefData
+refDataThis :: Typed.TypedTerm Syntax.ThisData -> Typed.TypedTerm Syntax.RefData
+refDataThis x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "this"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the init variant of hydra.scala.syntax.Ref
+refInit :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Ref
+refInit x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Ref"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "init"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the name variant of hydra.scala.syntax.Ref
+refName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Ref
+refName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Ref"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the name variant of hydra.scala.syntax.RefType
+refTypeName :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.RefType
+refTypeName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "name"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the project variant of hydra.scala.syntax.RefType
+refTypeProject :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.RefType
+refTypeProject x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "project"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the select variant of hydra.scala.syntax.RefType
+refTypeSelect :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.RefType
+refTypeSelect x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "select"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the singleton variant of hydra.scala.syntax.RefType
+refTypeSingleton :: Typed.TypedTerm Syntax.SingletonType -> Typed.TypedTerm Syntax.RefType
+refTypeSingleton x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefType"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "singleton"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.RefineType
+refineType :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.RefineType
+refineType tpe stats =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RefineType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm stats)}]}))
+
+-- | DSL accessor for the stats field of hydra.scala.syntax.RefineType
+refineTypeStats :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm [Syntax.Stat]
+refineTypeStats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RefineType"),
+        Core.projectionFieldName = (Core.Name "stats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.RefineType
+refineTypeTpe :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm (Maybe Syntax.Type)
+refineTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RefineType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the stats field of hydra.scala.syntax.RefineType
+refineTypeWithStats :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.RefineType
+refineTypeWithStats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RefineType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RefineType"),
+              Core.projectionFieldName = (Core.Name "tpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.RefineType
+refineTypeWithTpe :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.RefineType
+refineTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RefineType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RefineType"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.RenameImportee
+renameImportee :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RenameImportee
+renameImportee name rename =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rename"),
+          Core.fieldTerm = (Typed.unTypedTerm rename)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.RenameImportee
+renameImporteeName :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Name
+renameImporteeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rename field of hydra.scala.syntax.RenameImportee
+renameImporteeRename :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Name
+renameImporteeRename x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),
+        Core.projectionFieldName = (Core.Name "rename")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.RenameImportee
+renameImporteeWithName :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RenameImportee
+renameImporteeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rename"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),
+              Core.projectionFieldName = (Core.Name "rename")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rename field of hydra.scala.syntax.RenameImportee
+renameImporteeWithRename :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RenameImportee
+renameImporteeWithRename original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),
+      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.scala.syntax.RenameImportee"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rename"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.RepeatedData
+repeatedData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.RepeatedData
+repeatedData expr =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)}]}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.RepeatedData
+repeatedDataExpr :: Typed.TypedTerm Syntax.RepeatedData -> Typed.TypedTerm Syntax.Data
+repeatedDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.RepeatedData
+repeatedDataWithExpr :: Typed.TypedTerm Syntax.RepeatedData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.RepeatedData
+repeatedDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.RepeatedEnumCaseDefn
+repeatedEnumCaseDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.NameData] -> Typed.TypedTerm Syntax.RepeatedEnumCaseDefn
+repeatedEnumCaseDefn mods cases =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))
+
+-- | DSL accessor for the cases field of hydra.scala.syntax.RepeatedEnumCaseDefn
+repeatedEnumCaseDefnCases :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm [Syntax.NameData]
+repeatedEnumCaseDefnCases x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),
+        Core.projectionFieldName = (Core.Name "cases")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.RepeatedEnumCaseDefn
+repeatedEnumCaseDefnMods :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm [Syntax.Mod]
+repeatedEnumCaseDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the cases field of hydra.scala.syntax.RepeatedEnumCaseDefn
+repeatedEnumCaseDefnWithCases :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm [Syntax.NameData] -> Typed.TypedTerm Syntax.RepeatedEnumCaseDefn
+repeatedEnumCaseDefnWithCases original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.RepeatedEnumCaseDefn
+repeatedEnumCaseDefnWithMods :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.RepeatedEnumCaseDefn
+repeatedEnumCaseDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "cases"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),
+              Core.projectionFieldName = (Core.Name "cases")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.RepeatedPat
+repeatedPat :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.RepeatedPat
+repeatedPat name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.RepeatedPat
+repeatedPatName :: Typed.TypedTerm Syntax.RepeatedPat -> Typed.TypedTerm Syntax.NameData
+repeatedPatName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedPat"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.RepeatedPat
+repeatedPatWithName :: Typed.TypedTerm Syntax.RepeatedPat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.RepeatedPat
+repeatedPatWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.RepeatedType
+repeatedType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RepeatedType
+repeatedType tpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))
+
+-- | DSL accessor for the tpe field of hydra.scala.syntax.RepeatedType
+repeatedTypeTpe :: Typed.TypedTerm Syntax.RepeatedType -> Typed.TypedTerm Syntax.Type
+repeatedTypeTpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedType"),
+        Core.projectionFieldName = (Core.Name "tpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the tpe field of hydra.scala.syntax.RepeatedType
+repeatedTypeWithTpe :: Typed.TypedTerm Syntax.RepeatedType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RepeatedType
+repeatedTypeWithTpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "tpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ReturnData
+returnData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ReturnData
+returnData expr =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ReturnData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)}]}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.ReturnData
+returnDataExpr :: Typed.TypedTerm Syntax.ReturnData -> Typed.TypedTerm Syntax.Data
+returnDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ReturnData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.ReturnData
+returnDataWithExpr :: Typed.TypedTerm Syntax.ReturnData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ReturnData
+returnDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ReturnData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ScalaSymbol
+scalaSymbol :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ScalaSymbol
+scalaSymbol name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ScalaSymbol"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.ScalaSymbol
+scalaSymbolName :: Typed.TypedTerm Syntax.ScalaSymbol -> Typed.TypedTerm String
+scalaSymbolName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ScalaSymbol"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.ScalaSymbol
+scalaSymbolWithName :: Typed.TypedTerm Syntax.ScalaSymbol -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ScalaSymbol
+scalaSymbolWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ScalaSymbol"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.SecondaryCtor
+secondaryCtor :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Init -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.SecondaryCtor
+secondaryCtor mods name paramss init stats =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm paramss)},
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm init)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm stats)}]}))
+
+-- | DSL accessor for the init field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorInit :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Init
+secondaryCtorInit x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+        Core.projectionFieldName = (Core.Name "init")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorMods :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [Syntax.Mod]
+secondaryCtorMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorName :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Name
+secondaryCtorName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the paramss field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorParamss :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [[Syntax.ParamData]]
+secondaryCtorParamss x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+        Core.projectionFieldName = (Core.Name "paramss")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the stats field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorStats :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [Syntax.Stat]
+secondaryCtorStats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+        Core.projectionFieldName = (Core.Name "stats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the init field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorWithInit :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.SecondaryCtor
+secondaryCtorWithInit original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorWithMods :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.SecondaryCtor
+secondaryCtorWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorWithName :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SecondaryCtor
+secondaryCtorWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the paramss field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorWithParamss :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.SecondaryCtor
+secondaryCtorWithParamss original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the stats field of hydra.scala.syntax.SecondaryCtor
+secondaryCtorWithStats :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.SecondaryCtor
+secondaryCtorWithStats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "paramss"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "paramss")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "init"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),
+              Core.projectionFieldName = (Core.Name "init")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.SelectData
+selectData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.SelectData
+selectData qual name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          Core.fieldTerm = (Typed.unTypedTerm qual)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.SelectData
+selectDataName :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.NameData
+selectDataName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectData"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the qual field of hydra.scala.syntax.SelectData
+selectDataQual :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.Data
+selectDataQual x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectData"),
+        Core.projectionFieldName = (Core.Name "qual")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.SelectData
+selectDataWithName :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.SelectData
+selectDataWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectData"),
+              Core.projectionFieldName = (Core.Name "qual")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the qual field of hydra.scala.syntax.SelectData
+selectDataWithQual :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.SelectData
+selectDataWithQual original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          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.scala.syntax.SelectData"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.SelectType
+selectType :: Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.SelectType
+selectType qual name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          Core.fieldTerm = (Typed.unTypedTerm qual)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.SelectType
+selectTypeName :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.NameType
+selectTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectType"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the qual field of hydra.scala.syntax.SelectType
+selectTypeQual :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.RefData
+selectTypeQual x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectType"),
+        Core.projectionFieldName = (Core.Name "qual")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.SelectType
+selectTypeWithName :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.SelectType
+selectTypeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectType"),
+              Core.projectionFieldName = (Core.Name "qual")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the qual field of hydra.scala.syntax.SelectType
+selectTypeWithQual :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.SelectType
+selectTypeWithQual original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "qual"),
+          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.scala.syntax.SelectType"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for the hydra.scala.syntax.Self wrapper
+self :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.Self
+self x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.Self"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.scala.syntax.SingletonType
+singletonType :: Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.SingletonType
+singletonType ref =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SingletonType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Typed.unTypedTerm ref)}]}))
+
+-- | DSL accessor for the ref field of hydra.scala.syntax.SingletonType
+singletonTypeRef :: Typed.TypedTerm Syntax.SingletonType -> Typed.TypedTerm Syntax.RefData
+singletonTypeRef x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SingletonType"),
+        Core.projectionFieldName = (Core.Name "ref")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the ref field of hydra.scala.syntax.SingletonType
+singletonTypeWithRef :: Typed.TypedTerm Syntax.SingletonType -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.SingletonType
+singletonTypeWithRef original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SingletonType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "ref"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.Source
+source :: Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Source
+source stats =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Source"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm stats)}]}))
+
+-- | DSL accessor for the stats field of hydra.scala.syntax.Source
+sourceStats :: Typed.TypedTerm Syntax.Source -> Typed.TypedTerm [Syntax.Stat]
+sourceStats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Source"),
+        Core.projectionFieldName = (Core.Name "stats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the stats field of hydra.scala.syntax.Source
+sourceWithStats :: Typed.TypedTerm Syntax.Source -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Source
+sourceWithStats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Source"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the decl variant of hydra.scala.syntax.Stat
+statDecl :: Typed.TypedTerm Syntax.Decl -> Typed.TypedTerm Syntax.Stat
+statDecl x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Stat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "decl"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the defn variant of hydra.scala.syntax.Stat
+statDefn :: Typed.TypedTerm Syntax.Defn -> Typed.TypedTerm Syntax.Stat
+statDefn x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Stat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "defn"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the importExport variant of hydra.scala.syntax.Stat
+statImportExport :: Typed.TypedTerm Syntax.ImportExportStat -> Typed.TypedTerm Syntax.Stat
+statImportExport x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Stat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "importExport"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the term variant of hydra.scala.syntax.Stat
+statTerm :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Stat
+statTerm x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Stat"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "term"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.SuperData
+superData :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SuperData
+superData thisp superp =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SuperData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "thisp"),
+          Core.fieldTerm = (Typed.unTypedTerm thisp)},
+        Core.Field {
+          Core.fieldName = (Core.Name "superp"),
+          Core.fieldTerm = (Typed.unTypedTerm superp)}]}))
+
+-- | DSL accessor for the superp field of hydra.scala.syntax.SuperData
+superDataSuperp :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.Name
+superDataSuperp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SuperData"),
+        Core.projectionFieldName = (Core.Name "superp")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the thisp field of hydra.scala.syntax.SuperData
+superDataThisp :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.Name
+superDataThisp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SuperData"),
+        Core.projectionFieldName = (Core.Name "thisp")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the superp field of hydra.scala.syntax.SuperData
+superDataWithSuperp :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SuperData
+superDataWithSuperp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SuperData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "thisp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SuperData"),
+              Core.projectionFieldName = (Core.Name "thisp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "superp"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the thisp field of hydra.scala.syntax.SuperData
+superDataWithThisp :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SuperData
+superDataWithThisp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.SuperData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "thisp"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "superp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SuperData"),
+              Core.projectionFieldName = (Core.Name "superp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.Template
+template :: Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm [Syntax.Init] -> Typed.TypedTerm Syntax.Self -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Template
+template early inits self stats =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "early"),
+          Core.fieldTerm = (Typed.unTypedTerm early)},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Typed.unTypedTerm inits)},
+        Core.Field {
+          Core.fieldName = (Core.Name "self"),
+          Core.fieldTerm = (Typed.unTypedTerm self)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm stats)}]}))
+
+-- | DSL accessor for the early field of hydra.scala.syntax.Template
+templateEarly :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Stat]
+templateEarly x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+        Core.projectionFieldName = (Core.Name "early")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the inits field of hydra.scala.syntax.Template
+templateInits :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Init]
+templateInits x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+        Core.projectionFieldName = (Core.Name "inits")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the self field of hydra.scala.syntax.Template
+templateSelf :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.Self
+templateSelf x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+        Core.projectionFieldName = (Core.Name "self")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the stats field of hydra.scala.syntax.Template
+templateStats :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Stat]
+templateStats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+        Core.projectionFieldName = (Core.Name "stats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the early field of hydra.scala.syntax.Template
+templateWithEarly :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Template
+templateWithEarly original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "early"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "inits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "self"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "self")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the inits field of hydra.scala.syntax.Template
+templateWithInits :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Init] -> Typed.TypedTerm Syntax.Template
+templateWithInits original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "early"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "early")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "self"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "self")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the self field of hydra.scala.syntax.Template
+templateWithSelf :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.Self -> Typed.TypedTerm Syntax.Template
+templateWithSelf original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "early"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "early")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "inits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "self"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "stats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the stats field of hydra.scala.syntax.Template
+templateWithStats :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Template
+templateWithStats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "early"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "early")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "inits"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "inits")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "self"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),
+              Core.projectionFieldName = (Core.Name "self")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "stats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for the hydra.scala.syntax.ThisData wrapper
+thisData :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ThisData
+thisData x =
+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
+      Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.ThisData"),
+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.scala.syntax.ThrowData
+throwData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ThrowData
+throwData expr =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ThrowData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)}]}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.ThrowData
+throwDataExpr :: Typed.TypedTerm Syntax.ThrowData -> Typed.TypedTerm Syntax.Data
+throwDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ThrowData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.ThrowData
+throwDataWithExpr :: Typed.TypedTerm Syntax.ThrowData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ThrowData
+throwDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ThrowData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.TraitDefn
+traitDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.TraitDefn
+traitDefn mods name tparams ctor template =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Typed.unTypedTerm ctor)},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Typed.unTypedTerm template)}]}))
+
+-- | DSL accessor for the ctor field of hydra.scala.syntax.TraitDefn
+traitDefnCtor :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.PrimaryCtor
+traitDefnCtor x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+        Core.projectionFieldName = (Core.Name "ctor")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.TraitDefn
+traitDefnMods :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm [Syntax.Mod]
+traitDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.TraitDefn
+traitDefnName :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.NameType
+traitDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the template field of hydra.scala.syntax.TraitDefn
+traitDefnTemplate :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.Template
+traitDefnTemplate x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+        Core.projectionFieldName = (Core.Name "template")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.TraitDefn
+traitDefnTparams :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm [Syntax.ParamType]
+traitDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the ctor field of hydra.scala.syntax.TraitDefn
+traitDefnWithCtor :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.TraitDefn
+traitDefnWithCtor original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.TraitDefn
+traitDefnWithMods :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.TraitDefn
+traitDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.TraitDefn
+traitDefnWithName :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TraitDefn
+traitDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the template field of hydra.scala.syntax.TraitDefn
+traitDefnWithTemplate :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.TraitDefn
+traitDefnWithTemplate original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.TraitDefn
+traitDefnWithTparams :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.TraitDefn
+traitDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "ctor"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "ctor")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "template"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),
+              Core.projectionFieldName = (Core.Name "template")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the bounds variant of hydra.scala.syntax.Tree
+treeBounds :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.Tree
+treeBounds x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "bounds"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the caseTree variant of hydra.scala.syntax.Tree
+treeCaseTree :: Typed.TypedTerm Syntax.CaseTree -> Typed.TypedTerm Syntax.Tree
+treeCaseTree x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "caseTree"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ctor variant of hydra.scala.syntax.Tree
+treeCtor :: Typed.TypedTerm Syntax.Ctor -> Typed.TypedTerm Syntax.Tree
+treeCtor x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ctor"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the enumerator variant of hydra.scala.syntax.Tree
+treeEnumerator :: Typed.TypedTerm Syntax.Enumerator -> Typed.TypedTerm Syntax.Tree
+treeEnumerator x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "enumerator"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the importee variant of hydra.scala.syntax.Tree
+treeImportee :: Typed.TypedTerm Syntax.Importee -> Typed.TypedTerm Syntax.Tree
+treeImportee x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "importee"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the importer variant of hydra.scala.syntax.Tree
+treeImporter :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm Syntax.Tree
+treeImporter x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "importer"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the member variant of hydra.scala.syntax.Tree
+treeMember :: Typed.TypedTerm Syntax.Member -> Typed.TypedTerm Syntax.Tree
+treeMember x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "member"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the mod variant of hydra.scala.syntax.Tree
+treeMod :: Typed.TypedTerm Syntax.Mod -> Typed.TypedTerm Syntax.Tree
+treeMod x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "mod"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the pat variant of hydra.scala.syntax.Tree
+treePat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Tree
+treePat x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "pat"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ref variant of hydra.scala.syntax.Tree
+treeRef :: Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.Tree
+treeRef x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ref"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the source variant of hydra.scala.syntax.Tree
+treeSource :: Typed.TypedTerm Syntax.Source -> Typed.TypedTerm Syntax.Tree
+treeSource x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "source"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the stat variant of hydra.scala.syntax.Tree
+treeStat :: Typed.TypedTerm Syntax.Stat -> Typed.TypedTerm Syntax.Tree
+treeStat x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "stat"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the template variant of hydra.scala.syntax.Tree
+treeTemplate :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.Tree
+treeTemplate x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "template"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the type variant of hydra.scala.syntax.Tree
+treeType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Tree
+treeType x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "type"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.TryData
+tryData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.TryData
+tryData expr catchp finallyp =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catchp"),
+          Core.fieldTerm = (Typed.unTypedTerm catchp)},
+        Core.Field {
+          Core.fieldName = (Core.Name "finallyp"),
+          Core.fieldTerm = (Typed.unTypedTerm finallyp)}]}))
+
+-- | DSL accessor for the catchp field of hydra.scala.syntax.TryData
+tryDataCatchp :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm [Syntax.Case]
+tryDataCatchp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+        Core.projectionFieldName = (Core.Name "catchp")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.TryData
+tryDataExpr :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm Syntax.Data
+tryDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the finallyp field of hydra.scala.syntax.TryData
+tryDataFinallyp :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm (Maybe Syntax.Data)
+tryDataFinallyp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+        Core.projectionFieldName = (Core.Name "finallyp")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the catchp field of hydra.scala.syntax.TryData
+tryDataWithCatchp :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.TryData
+tryDataWithCatchp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catchp"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "finallyp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+              Core.projectionFieldName = (Core.Name "finallyp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.TryData
+tryDataWithExpr :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.TryData
+tryDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catchp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+              Core.projectionFieldName = (Core.Name "catchp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finallyp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+              Core.projectionFieldName = (Core.Name "finallyp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the finallyp field of hydra.scala.syntax.TryData
+tryDataWithFinallyp :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.TryData
+tryDataWithFinallyp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catchp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),
+              Core.projectionFieldName = (Core.Name "catchp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finallyp"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.TryWithHandlerData
+tryWithHandlerData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.TryWithHandlerData
+tryWithHandlerData expr catchp finallyp =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catchp"),
+          Core.fieldTerm = (Typed.unTypedTerm catchp)},
+        Core.Field {
+          Core.fieldName = (Core.Name "finallyp"),
+          Core.fieldTerm = (Typed.unTypedTerm finallyp)}]}))
+
+-- | DSL accessor for the catchp field of hydra.scala.syntax.TryWithHandlerData
+tryWithHandlerDataCatchp :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data
+tryWithHandlerDataCatchp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+        Core.projectionFieldName = (Core.Name "catchp")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.TryWithHandlerData
+tryWithHandlerDataExpr :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data
+tryWithHandlerDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the finallyp field of hydra.scala.syntax.TryWithHandlerData
+tryWithHandlerDataFinallyp :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm (Maybe Syntax.Data)
+tryWithHandlerDataFinallyp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+        Core.projectionFieldName = (Core.Name "finallyp")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the catchp field of hydra.scala.syntax.TryWithHandlerData
+tryWithHandlerDataWithCatchp :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.TryWithHandlerData
+tryWithHandlerDataWithCatchp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catchp"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "finallyp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+              Core.projectionFieldName = (Core.Name "finallyp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.TryWithHandlerData
+tryWithHandlerDataWithExpr :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.TryWithHandlerData
+tryWithHandlerDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "catchp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+              Core.projectionFieldName = (Core.Name "catchp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finallyp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+              Core.projectionFieldName = (Core.Name "finallyp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the finallyp field of hydra.scala.syntax.TryWithHandlerData
+tryWithHandlerDataWithFinallyp :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.TryWithHandlerData
+tryWithHandlerDataWithFinallyp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "catchp"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),
+              Core.projectionFieldName = (Core.Name "catchp")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "finallyp"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.TupleData
+tupleData :: Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.TupleData
+tupleData args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TupleData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.TupleData
+tupleDataArgs :: Typed.TypedTerm Syntax.TupleData -> Typed.TypedTerm [Syntax.Data]
+tupleDataArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TupleData"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.TupleData
+tupleDataWithArgs :: Typed.TypedTerm Syntax.TupleData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.TupleData
+tupleDataWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TupleData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.TuplePat
+tuplePat :: Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.TuplePat
+tuplePat args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TuplePat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.TuplePat
+tuplePatArgs :: Typed.TypedTerm Syntax.TuplePat -> Typed.TypedTerm [Syntax.Pat]
+tuplePatArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TuplePat"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.TuplePat
+tuplePatWithArgs :: Typed.TypedTerm Syntax.TuplePat -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.TuplePat
+tuplePatWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TuplePat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.TupleType
+tupleType :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.TupleType
+tupleType args =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TupleType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm args)}]}))
+
+-- | DSL accessor for the args field of hydra.scala.syntax.TupleType
+tupleTypeArgs :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm [Syntax.Type]
+tupleTypeArgs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TupleType"),
+        Core.projectionFieldName = (Core.Name "args")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the args field of hydra.scala.syntax.TupleType
+tupleTypeWithArgs :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.TupleType
+tupleTypeWithArgs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TupleType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "args"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the and variant of hydra.scala.syntax.Type
+typeAnd :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type
+typeAnd x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "and"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the annotate variant of hydra.scala.syntax.Type
+typeAnnotate :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm Syntax.Type
+typeAnnotate x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "annotate"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the anonymousName variant of hydra.scala.syntax.Type
+typeAnonymousName :: Typed.TypedTerm Syntax.AnonymousNameType -> Typed.TypedTerm Syntax.Type
+typeAnonymousName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "anonymousName"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the apply variant of hydra.scala.syntax.Type
+typeApply :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm Syntax.Type
+typeApply x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "apply"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the applyInfix variant of hydra.scala.syntax.Type
+typeApplyInfix :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type
+typeApplyInfix x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "applyInfix"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.TypeBounds
+typeBounds :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.TypeBounds
+typeBounds lo hi =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lo"),
+          Core.fieldTerm = (Typed.unTypedTerm lo)},
+        Core.Field {
+          Core.fieldName = (Core.Name "hi"),
+          Core.fieldTerm = (Typed.unTypedTerm hi)}]}))
+
+-- | DSL accessor for the hi field of hydra.scala.syntax.TypeBounds
+typeBoundsHi :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm (Maybe Syntax.Type)
+typeBoundsHi x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),
+        Core.projectionFieldName = (Core.Name "hi")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the lo field of hydra.scala.syntax.TypeBounds
+typeBoundsLo :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm (Maybe Syntax.Type)
+typeBoundsLo x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),
+        Core.projectionFieldName = (Core.Name "lo")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the hi field of hydra.scala.syntax.TypeBounds
+typeBoundsWithHi :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.TypeBounds
+typeBoundsWithHi original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lo"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),
+              Core.projectionFieldName = (Core.Name "lo")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "hi"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the lo field of hydra.scala.syntax.TypeBounds
+typeBoundsWithLo :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.TypeBounds
+typeBoundsWithLo original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "lo"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "hi"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),
+              Core.projectionFieldName = (Core.Name "hi")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the byName variant of hydra.scala.syntax.Type
+typeByName :: Typed.TypedTerm Syntax.ByNameType -> Typed.TypedTerm Syntax.Type
+typeByName x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "byName"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.TypeCase
+typeCase :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeCase
+typeCase pat body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Typed.unTypedTerm pat)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.TypeCase
+typeCaseBody :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.Type
+typeCaseBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the pat field of hydra.scala.syntax.TypeCase
+typeCasePat :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.Type
+typeCasePat x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),
+        Core.projectionFieldName = (Core.Name "pat")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.TypeCase
+typeCaseWithBody :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeCase
+typeCaseWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),
+              Core.projectionFieldName = (Core.Name "pat")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the pat field of hydra.scala.syntax.TypeCase
+typeCaseWithPat :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeCase
+typeCaseWithPat original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          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.scala.syntax.TypeCase"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the contextFunction variant of hydra.scala.syntax.Type
+typeContextFunction :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm Syntax.Type
+typeContextFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "contextFunction"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.TypeDecl
+typeDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.TypeDecl
+typeDecl mods name tparams bounds =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Typed.unTypedTerm bounds)}]}))
+
+-- | DSL accessor for the bounds field of hydra.scala.syntax.TypeDecl
+typeDeclBounds :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.TypeBounds
+typeDeclBounds x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+        Core.projectionFieldName = (Core.Name "bounds")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.TypeDecl
+typeDeclMods :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.Mod]
+typeDeclMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.TypeDecl
+typeDeclName :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.NameType
+typeDeclName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.TypeDecl
+typeDeclTparams :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.ParamType]
+typeDeclTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the bounds field of hydra.scala.syntax.TypeDecl
+typeDeclWithBounds :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.TypeDecl
+typeDeclWithBounds original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.TypeDecl
+typeDeclWithMods :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.TypeDecl
+typeDeclWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "bounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.TypeDecl
+typeDeclWithName :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TypeDecl
+typeDeclWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "bounds"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "bounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.TypeDecl
+typeDeclWithTparams :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.TypeDecl
+typeDeclWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          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.scala.syntax.TypeDecl"),
+              Core.projectionFieldName = (Core.Name "bounds")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.TypeDefn
+typeDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeDefn
+typeDefn mods name tparams body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Typed.unTypedTerm tparams)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.TypeDefn
+typeDefnBody :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.Type
+typeDefnBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.TypeDefn
+typeDefnMods :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm [Syntax.Mod]
+typeDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.TypeDefn
+typeDefnName :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.NameType
+typeDefnName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the tparams field of hydra.scala.syntax.TypeDefn
+typeDefnTparams :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm [Syntax.ParamType]
+typeDefnTparams x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+        Core.projectionFieldName = (Core.Name "tparams")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.TypeDefn
+typeDefnWithBody :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeDefn
+typeDefnWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.TypeDefn
+typeDefnWithMods :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.TypeDefn
+typeDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          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.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            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.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.TypeDefn
+typeDefnWithName :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TypeDefn
+typeDefnWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "tparams")})),
+            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.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the tparams field of hydra.scala.syntax.TypeDefn
+typeDefnWithTparams :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.TypeDefn
+typeDefnWithTparams original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            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.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "tparams"),
+          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.scala.syntax.TypeDefn"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL injection for the existential variant of hydra.scala.syntax.Type
+typeExistential :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm Syntax.Type
+typeExistential x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "existential"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the function variant of hydra.scala.syntax.Type
+typeFunction :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type
+typeFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "function"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the implicitFunction variant of hydra.scala.syntax.Type
+typeImplicitFunction :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm Syntax.Type
+typeImplicitFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "implicitFunction"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the lambda variant of hydra.scala.syntax.Type
+typeLambda :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm Syntax.Type
+typeLambda x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "lambda"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the match variant of hydra.scala.syntax.Type
+typeMatch :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm Syntax.Type
+typeMatch x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "match"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.TypeMember
+typeMember :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TypeMember
+typeMember name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeMember"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.TypeMember
+typeMemberName :: Typed.TypedTerm Syntax.TypeMember -> Typed.TypedTerm Syntax.NameType
+typeMemberName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeMember"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.TypeMember
+typeMemberWithName :: Typed.TypedTerm Syntax.TypeMember -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TypeMember
+typeMemberWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeMember"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL injection for the method variant of hydra.scala.syntax.Type
+typeMethod :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm Syntax.Type
+typeMethod x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "method"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the or variant of hydra.scala.syntax.Type
+typeOr :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type
+typeOr x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "or"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the placeholder variant of hydra.scala.syntax.Type
+typePlaceholder :: Typed.TypedTerm Syntax.PlaceholderType -> Typed.TypedTerm Syntax.Type
+typePlaceholder x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "placeholder"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the polyFunction variant of hydra.scala.syntax.Type
+typePolyFunction :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm Syntax.Type
+typePolyFunction x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "polyFunction"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the ref variant of hydra.scala.syntax.Type
+typeRef :: Typed.TypedTerm Syntax.RefType -> Typed.TypedTerm Syntax.Type
+typeRef x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "ref"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the refine variant of hydra.scala.syntax.Type
+typeRefine :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm Syntax.Type
+typeRefine x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "refine"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the repeated variant of hydra.scala.syntax.Type
+typeRepeated :: Typed.TypedTerm Syntax.RepeatedType -> Typed.TypedTerm Syntax.Type
+typeRepeated x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "repeated"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the tuple variant of hydra.scala.syntax.Type
+typeTuple :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm Syntax.Type
+typeTuple x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "tuple"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the typedParam variant of hydra.scala.syntax.Type
+typeTypedParam :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Type
+typeTypedParam x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "typedParam"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the var variant of hydra.scala.syntax.Type
+typeVar :: Typed.TypedTerm Syntax.VarType -> Typed.TypedTerm Syntax.Type
+typeVar x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "var"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL injection for the with variant of hydra.scala.syntax.Type
+typeWith :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type
+typeWith x =
+    Typed.TypedTerm (Core.TermInject (Core.Injection {
+      Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),
+      Core.injectionField = Core.Field {
+        Core.fieldName = (Core.Name "with"),
+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+
+-- | DSL constructor for hydra.scala.syntax.TypedParamType
+typedParamType :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedParamType
+typedParamType name typ =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typ"),
+          Core.fieldTerm = (Typed.unTypedTerm typ)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.TypedParamType
+typedParamTypeName :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Name
+typedParamTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the typ field of hydra.scala.syntax.TypedParamType
+typedParamTypeTyp :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Type
+typedParamTypeTyp x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),
+        Core.projectionFieldName = (Core.Name "typ")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.TypedParamType
+typedParamTypeWithName :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TypedParamType
+typedParamTypeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "typ"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),
+              Core.projectionFieldName = (Core.Name "typ")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the typ field of hydra.scala.syntax.TypedParamType
+typedParamTypeWithTyp :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedParamType
+typedParamTypeWithTyp original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),
+      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.scala.syntax.TypedParamType"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "typ"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.TypedPat
+typedPat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedPat
+typedPat lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),
+      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.scala.syntax.TypedPat
+typedPatLhs :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Pat
+typedPatLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.TypedPat
+typedPatRhs :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Type
+typedPatRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.TypedPat
+typedPatWithLhs :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.TypedPat
+typedPatWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),
+      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.scala.syntax.TypedPat"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.TypedPat
+typedPatWithRhs :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedPat
+typedPatWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),
+      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.scala.syntax.TypedPat"),
+              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 body of hydra.scala.syntax.AnonymousData
+unAnonymousData :: Typed.TypedTerm Syntax.AnonymousData -> Typed.TypedTerm ()
+unAnonymousData x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.AnonymousData")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.scala.syntax.AnonymousNameType
+unAnonymousNameType :: Typed.TypedTerm Syntax.AnonymousNameType -> Typed.TypedTerm ()
+unAnonymousNameType x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.AnonymousNameType")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.scala.syntax.PredefString
+unPredefString :: Typed.TypedTerm Syntax.PredefString -> Typed.TypedTerm String
+unPredefString x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.PredefString")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.scala.syntax.Self
+unSelf :: Typed.TypedTerm Syntax.Self -> Typed.TypedTerm ()
+unSelf x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.Self")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the body of hydra.scala.syntax.ThisData
+unThisData :: Typed.TypedTerm Syntax.ThisData -> Typed.TypedTerm ()
+unThisData x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.ThisData")),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL constructor for hydra.scala.syntax.UnimportImportee
+unimportImportee :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.UnimportImportee
+unimportImportee name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.UnimportImportee"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.UnimportImportee
+unimportImporteeName :: Typed.TypedTerm Syntax.UnimportImportee -> Typed.TypedTerm Syntax.Name
+unimportImporteeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.UnimportImportee"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.UnimportImportee
+unimportImporteeWithName :: Typed.TypedTerm Syntax.UnimportImportee -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.UnimportImportee
+unimportImporteeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.UnimportImportee"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ValDecl
+valDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ValDecl
+valDecl mods pats decltpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Typed.unTypedTerm pats)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)}]}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.ValDecl
+valDeclDecltpe :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm Syntax.Type
+valDeclDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.ValDecl
+valDeclMods :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm [Syntax.Mod]
+valDeclMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the pats field of hydra.scala.syntax.ValDecl
+valDeclPats :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm [Syntax.Pat]
+valDeclPats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+        Core.projectionFieldName = (Core.Name "pats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.ValDecl
+valDeclWithDecltpe :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ValDecl
+valDeclWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.ValDecl
+valDeclWithMods :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ValDecl
+valDeclWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the pats field of hydra.scala.syntax.ValDecl
+valDeclWithPats :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ValDecl
+valDeclWithPats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ValDefn
+valDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ValDefn
+valDefn mods pats decltpe rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Typed.unTypedTerm pats)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.ValDefn
+valDefnDecltpe :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm (Maybe Syntax.Type)
+valDefnDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.ValDefn
+valDefnMods :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm [Syntax.Mod]
+valDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the pats field of hydra.scala.syntax.ValDefn
+valDefnPats :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm [Syntax.Pat]
+valDefnPats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+        Core.projectionFieldName = (Core.Name "pats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.ValDefn
+valDefnRhs :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm Syntax.Data
+valDefnRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.ValDefn
+valDefnWithDecltpe :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.ValDefn
+valDefnWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          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.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.ValDefn
+valDefnWithMods :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ValDefn
+valDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the pats field of hydra.scala.syntax.ValDefn
+valDefnWithPats :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ValDefn
+valDefnWithPats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.ValDefn
+valDefnWithRhs :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ValDefn
+valDefnWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.ValEnumerator
+valEnumerator :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ValEnumerator
+valEnumerator pat rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Typed.unTypedTerm pat)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the pat field of hydra.scala.syntax.ValEnumerator
+valEnumeratorPat :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Pat
+valEnumeratorPat x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),
+        Core.projectionFieldName = (Core.Name "pat")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.ValEnumerator
+valEnumeratorRhs :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Data
+valEnumeratorRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the pat field of hydra.scala.syntax.ValEnumerator
+valEnumeratorWithPat :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.ValEnumerator
+valEnumeratorWithPat original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          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.scala.syntax.ValEnumerator"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.ValEnumerator
+valEnumeratorWithRhs :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ValEnumerator
+valEnumeratorWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "pat"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),
+              Core.projectionFieldName = (Core.Name "pat")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.VarDecl
+varDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VarDecl
+varDecl mods pats decltpe =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Typed.unTypedTerm pats)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)}]}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.VarDecl
+varDeclDecltpe :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm Syntax.Type
+varDeclDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.VarDecl
+varDeclMods :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.Mod]
+varDeclMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the pats field of hydra.scala.syntax.VarDecl
+varDeclPats :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.Pat]
+varDeclPats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+        Core.projectionFieldName = (Core.Name "pats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.VarDecl
+varDeclWithDecltpe :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VarDecl
+varDeclWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.VarDecl
+varDeclWithMods :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.VarDecl
+varDeclWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the pats field of hydra.scala.syntax.VarDecl
+varDeclWithPats :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.VarDecl
+varDeclWithPats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.VarDefn
+varDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.VarDefn
+varDefn mods pats decltpe rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm mods)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Typed.unTypedTerm pats)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Typed.unTypedTerm decltpe)},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
+
+-- | DSL accessor for the decltpe field of hydra.scala.syntax.VarDefn
+varDefnDecltpe :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm Syntax.Type
+varDefnDecltpe x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+        Core.projectionFieldName = (Core.Name "decltpe")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the mods field of hydra.scala.syntax.VarDefn
+varDefnMods :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm [Syntax.Mod]
+varDefnMods x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+        Core.projectionFieldName = (Core.Name "mods")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the pats field of hydra.scala.syntax.VarDefn
+varDefnPats :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm [Syntax.Pat]
+varDefnPats x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+        Core.projectionFieldName = (Core.Name "pats")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.VarDefn
+varDefnRhs :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm (Maybe Syntax.Data)
+varDefnRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the decltpe field of hydra.scala.syntax.VarDefn
+varDefnWithDecltpe :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VarDefn
+varDefnWithDecltpe original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          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.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the mods field of hydra.scala.syntax.VarDefn
+varDefnWithMods :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.VarDefn
+varDefnWithMods original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the pats field of hydra.scala.syntax.VarDefn
+varDefnWithPats :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.VarDefn
+varDefnWithPats original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.VarDefn
+varDefnWithRhs :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.VarDefn
+varDefnWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "mods"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "mods")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "pats"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "pats")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "decltpe"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),
+              Core.projectionFieldName = (Core.Name "decltpe")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.VarPat
+varPat :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.VarPat
+varPat name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.VarPat
+varPatName :: Typed.TypedTerm Syntax.VarPat -> Typed.TypedTerm Syntax.NameData
+varPatName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarPat"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.VarPat
+varPatWithName :: Typed.TypedTerm Syntax.VarPat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.VarPat
+varPatWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarPat"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.VarType
+varType :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.VarType
+varType name =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))
+
+-- | DSL accessor for the name field of hydra.scala.syntax.VarType
+varTypeName :: Typed.TypedTerm Syntax.VarType -> Typed.TypedTerm Syntax.NameType
+varTypeName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarType"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the name field of hydra.scala.syntax.VarType
+varTypeWithName :: Typed.TypedTerm Syntax.VarType -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.VarType
+varTypeWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarType"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL constructor for hydra.scala.syntax.WhileData
+whileData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.WhileData
+whileData expr body =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.WhileData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Typed.unTypedTerm expr)},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))
+
+-- | DSL accessor for the body field of hydra.scala.syntax.WhileData
+whileDataBody :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data
+whileDataBody x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WhileData"),
+        Core.projectionFieldName = (Core.Name "body")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the expr field of hydra.scala.syntax.WhileData
+whileDataExpr :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data
+whileDataExpr x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WhileData"),
+        Core.projectionFieldName = (Core.Name "expr")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the body field of hydra.scala.syntax.WhileData
+whileDataWithBody :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.WhileData
+whileDataWithBody original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.WhileData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WhileData"),
+              Core.projectionFieldName = (Core.Name "expr")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "body"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the expr field of hydra.scala.syntax.WhileData
+whileDataWithExpr :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.WhileData
+whileDataWithExpr original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.WhileData"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "expr"),
+          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.scala.syntax.WhileData"),
+              Core.projectionFieldName = (Core.Name "body")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL constructor for hydra.scala.syntax.WithType
+withType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.WithType
+withType lhs rhs =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.WithType"),
+      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.scala.syntax.WithType
+withTypeLhs :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type
+withTypeLhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WithType"),
+        Core.projectionFieldName = (Core.Name "lhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the rhs field of hydra.scala.syntax.WithType
+withTypeRhs :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type
+withTypeRhs x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WithType"),
+        Core.projectionFieldName = (Core.Name "rhs")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the lhs field of hydra.scala.syntax.WithType
+withTypeWithLhs :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.WithType
+withTypeWithLhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.WithType"),
+      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.scala.syntax.WithType"),
+              Core.projectionFieldName = (Core.Name "rhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the rhs field of hydra.scala.syntax.WithType
+withTypeWithRhs :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.WithType
+withTypeWithRhs original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.scala.syntax.WithType"),
+      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.scala.syntax.WithType"),
+              Core.projectionFieldName = (Core.Name "lhs")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "rhs"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
diff --git a/src/main/haskell/Hydra/Scala/Coder.hs b/src/main/haskell/Hydra/Scala/Coder.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Scala/Coder.hs
@@ -0,0 +1,955 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Scala code generator: converts Hydra modules to Scala source code
+
+module Hydra.Scala.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.Coders as Coders
+import qualified Hydra.Constants as Constants
+import qualified Hydra.Core as Core
+import qualified Hydra.Environment as Environment
+import qualified Hydra.Error.Checking as Checking
+import qualified Hydra.Error.Core as ErrorCore
+import qualified Hydra.Error.File as ErrorFile
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Error.System as ErrorSystem
+import qualified Hydra.Errors as Errors
+import qualified Hydra.File as File
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Inference as Inference
+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.Predicates as Predicates
+import qualified Hydra.Query as Query
+import qualified Hydra.Reduction as Reduction
+import qualified Hydra.Relational as Relational
+import qualified Hydra.Resolution as Resolution
+import qualified Hydra.Scala.Language as Language
+import qualified Hydra.Scala.Serde as Serde
+import qualified Hydra.Scala.Syntax as Syntax
+import qualified Hydra.Scala.Utils as Utils
+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.System as System
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Time as Time
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variables as Variables
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Map as M
+import qualified Data.Set as S
+
+-- | Apply a variable to a term, performing substitution for lambdas
+applyVar :: Core.Term -> Core.Name -> Core.Term
+applyVar fterm avar =
+
+      let v = Core.unName avar
+      in case (Strip.deannotateAndDetypeTerm fterm) of
+        Core.TermLambda v0 ->
+          let lamParam = Core.lambdaParameter v0
+              lamBody = Core.lambdaBody v0
+          in (Logic.ifElse (Variables.isFreeVariableInTerm lamParam lamBody) lamBody (Variables.substituteVariable lamParam avar lamBody))
+        _ -> Core.TermApplication (Core.Application {
+          Core.applicationFunction = fterm,
+          Core.applicationArgument = (Core.TermVariable avar)})
+
+-- | Construct a Scala package from a Hydra module and its definitions
+constructModule :: t0 -> Graph.Graph -> Packaging.Module -> [Packaging.Definition] -> Either Errors.Error Syntax.Pkg
+constructModule cx g mod defs =
+
+      let partitioned = Environment.partitionDefinitions defs
+          typeDefs = Pairs.first partitioned
+          termDefs = Pairs.second partitioned
+          nsName = Packaging.unModuleName (Packaging.moduleName mod)
+          pname =
+                  Syntax.NameData {
+                    Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." nsName)))}
+          pref = Syntax.RefDataName pname
+      in (Eithers.bind (Eithers.mapList (\td -> encodeTypeDefinition cx g td) typeDefs) (\typeDeclStats -> Eithers.bind (Eithers.mapList (\td -> encodeTermDefinition cx g td) termDefs) (\termDeclStats -> Eithers.bind (findImports cx g mod) (\imports -> Right (Syntax.Pkg {
+        Syntax.pkgName = pname,
+        Syntax.pkgRef = pref,
+        Syntax.pkgStats = (Lists.concat [
+          imports,
+          typeDeclStats,
+          termDeclStats])})))))
+
+-- | Drop N domain types from a function type, returning the remaining type
+dropDomains :: Int -> Core.Type -> Core.Type
+dropDomains n t =
+    Logic.ifElse (Equality.lte n 0) t (case (Strip.deannotateType t) of
+      Core.TypeFunction v0 -> dropDomains (Math.sub n 1) (Core.functionTypeCodomain v0)
+      Core.TypeForall v0 -> dropDomains n (Core.forallTypeBody v0)
+      _ -> t)
+
+-- | Encode a case branch
+encodeCase :: t0 -> Graph.Graph -> M.Map Core.Name Core.Type -> Maybe Core.Name -> Core.CaseAlternative -> Either Errors.Error Syntax.Case
+encodeCase cx g ftypes sn f =
+
+      let fname = Core.caseAlternativeName f
+          fterm = Core.caseAlternativeHandler f
+          isUnit =
+                  Optionals.cases (Maps.lookup fname ftypes) (case (Strip.deannotateAndDetypeTerm fterm) of
+                    Core.TermLambda v0 ->
+                      let lamParam = Core.lambdaParameter v0
+                          lamBody = Core.lambdaBody v0
+                          domIsUnit = Optionals.cases (Core.lambdaDomain v0) False (\dom -> Equality.equal dom Core.TypeUnit)
+                          bodyIgnoresParam = Variables.isFreeVariableInTerm lamParam lamBody
+                      in (Logic.or domIsUnit bodyIgnoresParam)
+                    Core.TermRecord v0 -> Equality.equal (Lists.length (Core.recordFields v0)) 0
+                    Core.TermUnit -> True
+                    _ -> False) (\dom -> case (Strip.deannotateType dom) of
+                    Core.TypeUnit -> True
+                    Core.TypeRecord v0 -> Equality.equal (Lists.length v0) 0
+                    _ -> False)
+          shortTypeName =
+                  Optionals.fromOptional "x" (Lists.maybeLast (Strings.splitOn "." (Optionals.cases sn "x" (\n -> Core.unName n))))
+          lamParamSuffix =
+                  case (Strip.deannotateAndDetypeTerm fterm) of
+                    Core.TermLambda v0 ->
+                      let rawName = Core.unName (Core.lambdaParameter v0)
+                          safeName = Strings.fromList (Lists.map (\c -> Logic.ifElse (Equality.equal c 39) 95 c) (Strings.toList rawName))
+                      in (Strings.cat2 "_" safeName)
+                    _ -> ""
+          v =
+                  Core.Name (Strings.cat [
+                    "v_",
+                    shortTypeName,
+                    "_",
+                    (Core.unName fname),
+                    lamParamSuffix])
+          domainIsUnit =
+                  case (Strip.deannotateAndDetypeTerm fterm) of
+                    Core.TermLambda v0 -> Optionals.cases (Core.lambdaDomain v0) True (\dom -> Equality.equal dom Core.TypeUnit)
+                    _ -> True
+          patArgs = Logic.ifElse isUnit (Logic.ifElse domainIsUnit [] [
+                Syntax.PatWildcard]) [
+                Utils.svar v]
+          pat =
+                  Syntax.PatExtract (Syntax.ExtractPat {
+                    Syntax.extractPatFun = (Utils.sname (Utils.qualifyUnionFieldName "MATCHED." sn fname)),
+                    Syntax.extractPatArgs = patArgs})
+          applied = applyVar fterm v
+      in (Eithers.bind (encodeTerm cx g applied) (\body -> Right (Syntax.Case {
+        Syntax.casePat = pat,
+        Syntax.caseCond = Nothing,
+        Syntax.caseBody = body})))
+
+-- | Encode a complex term definition with proper parameter types from the type signature
+encodeComplexTermDef :: t0 -> Graph.Graph -> String -> Core.Term -> Core.Type -> Either Errors.Error Syntax.Stat
+encodeComplexTermDef cx g lname term typ =
+
+      let doms = extractDomains typ
+          paramNames = extractParams term
+          paramCount = Math.min (Lists.length paramNames) (Lists.length doms)
+          cod = dropDomains paramCount typ
+          zippedParams = Lists.zip (Lists.take paramCount paramNames) (Lists.take paramCount doms)
+          freeTypeVars =
+                  Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ))
+          tparams = Lists.map (\tv -> Utils.stparam tv) freeTypeVars
+          letBindings = extractLetBindings term
+          gWithTypeVars =
+                  Graph.Graph {
+                    Graph.graphBoundTerms = (Graph.graphBoundTerms g),
+                    Graph.graphBoundTypes = (Graph.graphBoundTypes g),
+                    Graph.graphClassConstraints = (Graph.graphClassConstraints g),
+                    Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),
+                    Graph.graphMetadata = (Graph.graphMetadata g),
+                    Graph.graphPrimitives = (Graph.graphPrimitives g),
+                    Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),
+                    Graph.graphTypeVariables = (Sets.union (Sets.fromList freeTypeVars) (Graph.graphTypeVariables g))}
+      in (Eithers.bind (Eithers.mapList (encodeTypedParam cx gWithTypeVars) zippedParams) (\sparams -> Eithers.bind (encodeTerm cx gWithTypeVars (extractBody term)) (\sbody -> Eithers.bind (encodeType cx g cod) (\scod ->
+        let gForLets =
+                Logic.ifElse (Lists.null letBindings) gWithTypeVars (Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing) gWithTypeVars (Core.Let {
+                  Core.letBindings = letBindings,
+                  Core.letBody = (Core.TermVariable (Core.Name "dummy"))}))
+        in (Eithers.bind (Eithers.mapList (encodeLetBinding cx gForLets (Sets.fromList freeTypeVars)) letBindings) (\sbindings ->
+          let defBody =
+                  Logic.ifElse (Lists.null sbindings) sbody (Syntax.DataBlock (Syntax.BlockData {
+                    Syntax.blockDataStats = (Lists.concat2 sbindings [
+                      Syntax.StatTerm sbody])}))
+          in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {
+            Syntax.defDefnMods = [],
+            Syntax.defDefnName = Syntax.NameData {
+              Syntax.nameDataValue = (Syntax.PredefString lname)},
+            Syntax.defDefnTparams = tparams,
+            Syntax.defDefnParamss = (Lists.map (\p -> [
+              p]) sparams),
+            Syntax.defDefnDecltpe = (Just scod),
+            Syntax.defDefnBody = defBody}))))))))))
+
+-- | Encode a Hydra function-valued term (lambda, project, cases, or unwrap) as a Scala expression
+encodeFunction :: t0 -> Graph.Graph -> M.Map Core.Name Core.Term -> Core.Term -> Maybe Core.Term -> Either Errors.Error Syntax.Data
+encodeFunction cx g meta funTerm arg =
+    case (Strip.deannotateAndDetypeTerm funTerm) of
+      Core.TermLambda v0 ->
+        let param = Core.lambdaParameter v0
+            v = Utils.scalaEscapeName (Core.unName param)
+            body = Core.lambdaBody v0
+            rawMdom = Core.lambdaDomain v0
+            mdom =
+                    Optionals.bind rawMdom (\dom ->
+                      let freeVars = Variables.freeVariablesInType dom
+                          unqualifiedFreeVars =
+                                  Sets.fromList (Lists.filter (\n -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName n)))) (Sets.toList freeVars))
+                          unresolvedVars = Sets.difference unqualifiedFreeVars (Graph.graphTypeVariables g)
+                      in (Logic.ifElse (Sets.null unresolvedVars) (Just dom) Nothing))
+        in (Eithers.bind (encodeTerm cx g body) (\sbody -> Eithers.bind (Optionals.cases mdom (findSdom cx g meta) (\dom -> Eithers.bind (encodeType cx g dom) (\sdom -> Right (Just sdom)))) (\sdom -> Right (Utils.slambda v sbody sdom))))
+      Core.TermUnwrap _ -> Optionals.cases arg (Eithers.bind (findSdom cx g meta) (\sdom -> Right (Utils.slambda "x" (Utils.sname "x") sdom))) (\a -> encodeTerm cx g a)
+      Core.TermProject v0 ->
+        let fname = Utils.scalaEscapeName (Core.unName (Core.projectionFieldName v0))
+            typeName = Core.projectionTypeName v0
+            pv = "x"
+        in (Optionals.cases arg (Eithers.bind (Eithers.either (\_ -> Right Nothing) (\msdom -> Right msdom) (findSdom cx g meta)) (\msdom -> Right (Utils.slambda pv (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {
+          Syntax.selectDataQual = (Utils.sname pv),
+          Syntax.selectDataName = Syntax.NameData {
+            Syntax.nameDataValue = (Syntax.PredefString fname)}}))) msdom))) (\a -> Eithers.bind (encodeTerm cx g a) (\sa -> Right (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {
+          Syntax.selectDataQual = sa,
+          Syntax.selectDataName = Syntax.NameData {
+            Syntax.nameDataValue = (Syntax.PredefString fname)}}))))))
+      Core.TermCases v0 ->
+        let v = "v"
+            tname = Core.caseStatementTypeName v0
+            dom = Core.TypeVariable tname
+            sn = Utils.nameOfType g dom
+            cases = Core.caseStatementCases v0
+            dflt = Core.caseStatementDefault v0
+            ftypes = Eithers.either (\_ -> Maps.empty) (\x_ -> x_) (Resolution.fieldTypes cx g dom)
+        in (Eithers.bind (Eithers.mapList (\f -> encodeCase cx g ftypes sn f) cases) (\fieldCases -> Eithers.bind (Optionals.cases dflt (Right fieldCases) (\dfltTerm -> Eithers.bind (encodeTerm cx g dfltTerm) (\sdflt -> Right (Lists.concat2 fieldCases [
+          Syntax.Case {
+            Syntax.casePat = Syntax.PatWildcard,
+            Syntax.caseCond = Nothing,
+            Syntax.caseBody = sdflt}])))) (\scases -> Optionals.cases arg (Eithers.bind (findSdom cx g meta) (\sdom -> Right (Utils.slambda v (Syntax.DataMatch (Syntax.MatchData {
+          Syntax.matchDataExpr = (Utils.sname v),
+          Syntax.matchDataCases = scases})) sdom))) (\a -> Eithers.bind (encodeTerm cx g a) (\sa -> Right (Syntax.DataMatch (Syntax.MatchData {
+          Syntax.matchDataExpr = sa,
+          Syntax.matchDataCases = scases})))))))
+      _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported function"))
+
+-- | Encode a let binding as a val or def declaration. outerTypeVars are type params from the enclosing scope.
+encodeLetBinding :: t0 -> Graph.Graph -> S.Set Core.Name -> Core.Binding -> Either Errors.Error Syntax.Stat
+encodeLetBinding cx g outerTypeVars b =
+
+      let bname = Utils.scalaEscapeName (Core.unName (Core.bindingName b))
+          bterm = Core.bindingTerm b
+          mts = Optionals.cases (Core.bindingTypeScheme b) (Maps.lookup (Core.bindingName b) (Graph.graphBoundTypes g)) (\ts -> Just ts)
+          isFn =
+                  Optionals.cases mts 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)
+      in (Optionals.cases mts (Eithers.bind (encodeTerm cx g bterm) (\srhs -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {
+        Syntax.valDefnMods = [
+          Syntax.ModLazy],
+        Syntax.valDefnPats = [
+          Syntax.PatVar (Syntax.VarPat {
+            Syntax.varPatName = Syntax.NameData {
+              Syntax.nameDataValue = (Syntax.PredefString bname)}})],
+        Syntax.valDefnDecltpe = Nothing,
+        Syntax.valDefnRhs = srhs}))))) (\ts ->
+        let newVars = Lists.filter (\v -> Logic.not (Sets.member v outerTypeVars)) (Core.typeSchemeVariables ts)
+            useDef = Logic.or isFn (Logic.not (Lists.null newVars))
+        in (Logic.ifElse useDef (encodeLocalDef cx g outerTypeVars bname bterm (Core.typeSchemeBody ts)) (Eithers.bind (encodeTerm cx g bterm) (\srhs -> Eithers.bind (encodeType cx g (Core.typeSchemeBody ts)) (\styp -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {
+          Syntax.valDefnMods = [
+            Syntax.ModLazy],
+          Syntax.valDefnPats = [
+            Syntax.PatVar (Syntax.VarPat {
+              Syntax.varPatName = Syntax.NameData {
+                Syntax.nameDataValue = (Syntax.PredefString bname)}})],
+          Syntax.valDefnDecltpe = (Just styp),
+          Syntax.valDefnRhs = srhs})))))))))
+
+-- | Encode a literal value as a Scala literal
+encodeLiteral :: t0 -> t1 -> Core.Literal -> Either Errors.Error Syntax.Lit
+encodeLiteral cx g av =
+    case av of
+      Core.LiteralBinary v0 -> Right (Syntax.LitBytes (Literals.binaryToBytes v0))
+      Core.LiteralBoolean v0 -> Right (Syntax.LitBoolean v0)
+      Core.LiteralDecimal v0 -> Right (Syntax.LitString (Literals.showDecimal v0))
+      Core.LiteralFloat v0 -> case v0 of
+        Core.FloatValueFloat32 v1 -> Right (Syntax.LitFloat v1)
+        Core.FloatValueFloat64 v1 -> Right (Syntax.LitDouble v1)
+        _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected float value"))
+      Core.LiteralInteger v0 -> case v0 of
+        Core.IntegerValueBigint v1 -> Right (Syntax.LitLong (Literals.bigintToInt64 v1))
+        Core.IntegerValueInt8 v1 -> Right (Syntax.LitByte v1)
+        Core.IntegerValueInt16 v1 -> Right (Syntax.LitShort v1)
+        Core.IntegerValueInt32 v1 -> Right (Syntax.LitInt v1)
+        Core.IntegerValueInt64 v1 -> Right (Syntax.LitLong v1)
+        Core.IntegerValueUint8 v1 -> Right (Syntax.LitByte (Literals.bigintToInt8 (Literals.uint8ToBigint v1)))
+        Core.IntegerValueUint16 v1 -> Right (Syntax.LitInt (Literals.bigintToInt32 (Literals.uint16ToBigint v1)))
+        Core.IntegerValueUint32 v1 -> Right (Syntax.LitLong (Literals.bigintToInt64 (Literals.uint32ToBigint v1)))
+        Core.IntegerValueUint64 v1 -> Right (Syntax.LitLong (Literals.bigintToInt64 (Literals.uint64ToBigint v1)))
+        _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected integer value"))
+      Core.LiteralString v0 -> Right (Syntax.LitString v0)
+      _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected literal"))
+
+-- | Encode a local def. outerTypeVars are type params already in scope (don't redeclare them).
+encodeLocalDef :: t0 -> Graph.Graph -> S.Set Core.Name -> String -> Core.Term -> Core.Type -> Either Errors.Error Syntax.Stat
+encodeLocalDef cx g outerTypeVars lname term typ =
+
+      let freeTypeVars =
+              Lists.filter (\v -> Logic.and (Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Logic.not (Sets.member v outerTypeVars))) (Sets.toList (Variables.freeVariablesInType typ))
+          doms = extractDomains typ
+          paramNames = extractParams term
+          paramCount = Math.min (Lists.length paramNames) (Lists.length doms)
+          cod = dropDomains paramCount typ
+          zippedParams = Lists.zip (Lists.take paramCount paramNames) (Lists.take paramCount doms)
+          letBindings = extractLetBindings term
+          tparams = Lists.map (\tv -> Utils.stparam tv) freeTypeVars
+          allTypeVars = Sets.union outerTypeVars (Sets.fromList freeTypeVars)
+          gWithTypeVars =
+                  Graph.Graph {
+                    Graph.graphBoundTerms = (Graph.graphBoundTerms g),
+                    Graph.graphBoundTypes = (Graph.graphBoundTypes g),
+                    Graph.graphClassConstraints = (Graph.graphClassConstraints g),
+                    Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),
+                    Graph.graphMetadata = (Graph.graphMetadata g),
+                    Graph.graphPrimitives = (Graph.graphPrimitives g),
+                    Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),
+                    Graph.graphTypeVariables = (Sets.union allTypeVars (Graph.graphTypeVariables g))}
+      in (Eithers.bind (Eithers.mapList (encodeTypedParam cx gWithTypeVars) zippedParams) (\sparams -> Eithers.bind (encodeTerm cx gWithTypeVars (extractBody term)) (\sbody -> Eithers.bind (encodeType cx gWithTypeVars cod) (\scod ->
+        let gForLets =
+                Logic.ifElse (Lists.null letBindings) gWithTypeVars (Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing) gWithTypeVars (Core.Let {
+                  Core.letBindings = letBindings,
+                  Core.letBody = (Core.TermVariable (Core.Name "dummy"))}))
+        in (Eithers.bind (Eithers.mapList (encodeLetBinding cx gForLets allTypeVars) letBindings) (\sbindings ->
+          let defBody =
+                  Logic.ifElse (Lists.null sbindings) sbody (Syntax.DataBlock (Syntax.BlockData {
+                    Syntax.blockDataStats = (Lists.concat2 sbindings [
+                      Syntax.StatTerm sbody])}))
+          in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {
+            Syntax.defDefnMods = [],
+            Syntax.defDefnName = Syntax.NameData {
+              Syntax.nameDataValue = (Syntax.PredefString lname)},
+            Syntax.defDefnTparams = tparams,
+            Syntax.defDefnParamss = (Lists.map (\p -> [
+              p]) sparams),
+            Syntax.defDefnDecltpe = (Just scod),
+            Syntax.defDefnBody = defBody}))))))))))
+
+-- | Encode a Hydra term as a Scala expression
+encodeTerm :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error Syntax.Data
+encodeTerm cx g term0 =
+
+      let term = stripWrapEliminations term0
+      in case (Strip.deannotateTerm term) of
+        Core.TermTypeApplication v0 ->
+          let collectTypeArgs =
+                  \t -> \acc -> case (Strip.deannotateTerm t) of
+                    Core.TermTypeApplication v1 -> collectTypeArgs (Core.typeApplicationTermBody v1) (Lists.cons (Core.typeApplicationTermType v1) acc)
+                    _ -> (acc, t)
+              collected = collectTypeArgs (Core.typeApplicationTermBody v0) [
+                    Core.typeApplicationTermType v0]
+              typeArgs = Pairs.first collected
+              innerTerm = Pairs.second collected
+              collectTypeLambdas =
+                      \t -> \acc -> case (Strip.deannotateTerm t) of
+                        Core.TermTypeLambda v1 -> collectTypeLambdas (Core.typeLambdaBody v1) (Lists.cons (Core.typeLambdaParameter v1) acc)
+                        _ -> (acc, t)
+              tlCollected = collectTypeLambdas innerTerm []
+              typeParams = Pairs.first tlCollected
+              bodyAfterTypeLambdas = Pairs.second tlCollected
+              substitutedBody = bodyAfterTypeLambdas
+          in case (Strip.deannotateTerm substitutedBody) of
+            Core.TermProject _ -> encodeTerm cx g substitutedBody
+            Core.TermCases _ -> encodeTerm cx g substitutedBody
+            Core.TermUnwrap _ -> encodeTerm cx g substitutedBody
+            Core.TermVariable v1 -> Eithers.bind (Eithers.mapList (\targ -> encodeType cx g targ) typeArgs) (\stypeArgs -> Optionals.cases (Maps.lookup v1 (Graph.graphPrimitives g)) (Eithers.bind (encodeTerm cx g substitutedBody) (\svar -> Right (Utils.sapplyTypes svar stypeArgs))) (\_prim -> Right (Utils.sapplyTypes (Utils.sprim v1) stypeArgs)))
+            _ -> encodeTerm cx g substitutedBody
+        Core.TermTypeLambda v0 -> encodeTerm cx (Scoping.extendGraphForTypeLambda g v0) (Core.typeLambdaBody v0)
+        Core.TermApplication v0 ->
+          let fun = Core.applicationFunction v0
+              arg = Core.applicationArgument v0
+          in case (Strip.deannotateAndDetypeTerm fun) of
+            Core.TermLambda v1 ->
+              let lamBody = Core.lambdaBody v1
+              in case (Strip.deannotateAndDetypeTerm lamBody) of
+                Core.TermApplication v2 ->
+                  let innerFun = Core.applicationFunction v2
+                  in case (Strip.deannotateAndDetypeTerm innerFun) of
+                    Core.TermCases _ -> encodeFunction cx g (Annotations.termAnnotationInternal innerFun) innerFun (Just arg)
+                    _ -> Eithers.bind (encodeTerm cx g fun) (\sfun -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Utils.sapply sfun [
+                      sarg])))
+                _ -> Eithers.bind (encodeTerm cx g fun) (\sfun -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Utils.sapply sfun [
+                  sarg])))
+            Core.TermProject v1 ->
+              let fname = Utils.scalaEscapeName (Core.unName (Core.projectionFieldName v1))
+              in (Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {
+                Syntax.selectDataQual = sarg,
+                Syntax.selectDataName = Syntax.NameData {
+                  Syntax.nameDataValue = (Syntax.PredefString fname)}})))))
+            Core.TermCases _ -> encodeFunction cx g (Annotations.termAnnotationInternal fun) fun (Just arg)
+            _ -> Eithers.bind (encodeTerm cx g fun) (\sfun -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Utils.sapply sfun [
+              sarg])))
+        Core.TermLambda _ -> encodeFunction cx g (Annotations.termAnnotationInternal term) term Nothing
+        Core.TermProject _ -> encodeFunction cx g (Annotations.termAnnotationInternal term) term Nothing
+        Core.TermCases _ -> encodeFunction cx g (Annotations.termAnnotationInternal term) term Nothing
+        Core.TermUnwrap _ -> encodeFunction cx g (Annotations.termAnnotationInternal term) term Nothing
+        Core.TermList v0 -> Eithers.bind (Eithers.mapList (\e -> encodeTerm cx g e) v0) (\sels -> Right (Utils.sapply (Utils.sname "Seq") sels))
+        Core.TermLiteral v0 -> Eithers.bind (encodeLiteral cx g v0) (\slit ->
+          let litData = Syntax.DataLit slit
+          in case v0 of
+            Core.LiteralDecimal _ -> Right (Utils.sapply (Utils.sname "BigDecimal") [
+              litData])
+            Core.LiteralInteger v1 -> case v1 of
+              Core.IntegerValueBigint v2 -> Right (Utils.sapply (Utils.sname "BigInt") [
+                Syntax.DataLit (Syntax.LitString (Literals.showBigint v2))])
+              Core.IntegerValueUint64 v2 -> Right (Utils.sapply (Utils.sname "BigInt") [
+                Syntax.DataLit (Syntax.LitString (Literals.showBigint (Literals.uint64ToBigint v2)))])
+              _ -> Right litData
+            _ -> Right litData)
+        Core.TermMap v0 -> Eithers.bind (Eithers.mapList (\kv -> Eithers.bind (encodeTerm cx g (Pairs.first kv)) (\sk -> Eithers.bind (encodeTerm cx g (Pairs.second kv)) (\sv -> Right (Utils.sassign sk sv)))) (Maps.toList v0)) (\spairs -> Right (Utils.sapply (Utils.sname "Map") spairs))
+        Core.TermWrap v0 -> encodeTerm cx g (Core.wrappedTermBody v0)
+        Core.TermOptional v0 -> Optionals.cases v0 (Right (Utils.sname "None")) (\t -> Eithers.bind (encodeTerm cx g t) (\s -> Right (Utils.sapply (Utils.sname "Some") [
+          s])))
+        Core.TermRecord v0 ->
+          let rname = Core.recordTypeName v0
+              fields = Core.recordFields v0
+              n = Utils.scalaTypeName True rname
+          in (Eithers.bind (Eithers.mapList (\f -> encodeTerm cx g (Core.fieldTerm f)) fields) (\args -> Right (Utils.sapply (Utils.sname n) args)))
+        Core.TermSet v0 -> Eithers.bind (Eithers.mapList (\e -> encodeTerm cx g e) (Sets.toList v0)) (\sels -> Right (Utils.sapply (Utils.sname "scala.collection.immutable.Set") sels))
+        Core.TermInject v0 ->
+          let sn = Core.injectionTypeName v0
+              fn = Core.fieldName (Core.injectionField v0)
+              ft = Core.fieldTerm (Core.injectionField v0)
+              lhs = Utils.sname (Utils.qualifyUnionFieldName "UNION." (Just sn) fn)
+              unionFtypes = Eithers.either (\_ -> Maps.empty) (\x_ -> x_) (Resolution.fieldTypes cx g (Core.TypeVariable sn))
+          in (Logic.ifElse (Optionals.cases (Maps.lookup fn unionFtypes) (case (Strip.deannotateAndDetypeTerm ft) of
+            Core.TermUnit -> True
+            Core.TermRecord v1 -> Equality.equal (Lists.length (Core.recordFields v1)) 0
+            _ -> False) (\dom -> case (Strip.deannotateType dom) of
+            Core.TypeUnit -> True
+            Core.TypeRecord v1 -> Equality.equal (Lists.length v1) 0
+            _ -> False)) (Right lhs) (Eithers.bind (encodeTerm cx g ft) (\sarg -> Right (Utils.sapply lhs [
+            sarg]))))
+        Core.TermVariable v0 ->
+          let fullName = Core.unName v0
+              localName = Names.localNameOf v0
+              parts = Strings.splitOn "." fullName
+              numParts = Lists.length parts
+              escaped =
+                      Logic.ifElse (Equality.lte numParts 1) (Utils.scalaEscapeName fullName) (Logic.ifElse (Equality.equal numParts 2) (Strings.cat2 (Optionals.fromOptional fullName (Lists.maybeHead parts)) (Strings.cat2 "." (Utils.scalaEscapeName localName))) (Strings.intercalate "." (Lists.concat2 (Lists.take (Math.sub numParts 1) parts) [
+                        Utils.scalaEscapeName localName])))
+          in (Right (Utils.sname escaped))
+        Core.TermAnnotated v0 -> encodeTerm cx g (Core.annotatedTermBody v0)
+        Core.TermEither v0 -> Eithers.either (\l -> Eithers.bind (encodeTerm cx g l) (\sl -> Right (Utils.sapply (Utils.sname "Left") [
+          sl]))) (\r -> Eithers.bind (encodeTerm cx g r) (\sr -> Right (Utils.sapply (Utils.sname "Right") [
+          sr]))) v0
+        Core.TermPair v0 -> Eithers.bind (encodeTerm cx g (Pairs.first v0)) (\sf -> Eithers.bind (encodeTerm cx g (Pairs.second v0)) (\ss -> Right (Utils.sapply (Utils.sname "Tuple2") [
+          sf,
+          ss])))
+        Core.TermUnit -> Right (Syntax.DataLit Syntax.LitUnit)
+        Core.TermLet v0 ->
+          let bindings = Core.letBindings v0
+              body = Core.letBody v0
+              gLet =
+                      Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing) g v0
+          in (Eithers.bind (Eithers.mapList (encodeLetBinding cx gLet (Graph.graphTypeVariables gLet)) bindings) (\sbindings -> Eithers.bind (encodeTerm cx gLet body) (\sbody -> Right (Syntax.DataBlock (Syntax.BlockData {
+            Syntax.blockDataStats = (Lists.concat2 sbindings [
+              Syntax.StatTerm sbody])})))))
+        _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected term"))
+
+-- | Encode a term definition as a Scala statement
+encodeTermDefinition :: t0 -> Graph.Graph -> Packaging.TermDefinition -> Either Errors.Error Syntax.Stat
+encodeTermDefinition cx g td =
+
+      let name = Packaging.termDefinitionName td
+          term = Packaging.termDefinitionBody td
+          lname = Utils.scalaEscapeName (Names.localNameOf name)
+          typ_ =
+                  Optionals.cases (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature td)) (Core.TypeVariable (Core.Name "hydra.core.Unit")) Core.typeSchemeBody
+          isFunctionType =
+                  case (Strip.deannotateType typ_) of
+                    Core.TypeFunction _ -> True
+                    Core.TypeForall v0 -> case (Strip.deannotateType (Core.forallTypeBody v0)) of
+                      Core.TypeFunction _ -> True
+                      _ -> False
+                    _ -> False
+          freeTypeVarsInTyp =
+                  Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ_))
+      in (Logic.ifElse isFunctionType (encodeComplexTermDef cx g lname term typ_) (Logic.ifElse (Lists.null freeTypeVarsInTyp) (Eithers.bind (encodeType cx g typ_) (\stype -> Eithers.bind (encodeTerm cx g term) (\rhs -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {
+        Syntax.valDefnMods = [
+          Syntax.ModLazy],
+        Syntax.valDefnPats = [
+          Syntax.PatVar (Syntax.VarPat {
+            Syntax.varPatName = Syntax.NameData {
+              Syntax.nameDataValue = (Syntax.PredefString lname)}})],
+        Syntax.valDefnDecltpe = (Just stype),
+        Syntax.valDefnRhs = rhs})))))) (Eithers.bind (encodeType cx g typ_) (\stype -> Eithers.bind (encodeTerm cx g term) (\rhs ->
+        let tparams = Lists.map (\tv -> Utils.stparam tv) freeTypeVarsInTyp
+        in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {
+          Syntax.defDefnMods = [],
+          Syntax.defDefnName = Syntax.NameData {
+            Syntax.nameDataValue = (Syntax.PredefString lname)},
+          Syntax.defDefnTparams = tparams,
+          Syntax.defDefnParamss = [],
+          Syntax.defDefnDecltpe = (Just stype),
+          Syntax.defDefnBody = rhs})))))))))
+
+-- | Encode a Hydra type as a Scala type
+encodeType :: t0 -> t1 -> Core.Type -> Either Errors.Error Syntax.Type
+encodeType cx g t =
+    case (Strip.deannotateType t) of
+      Core.TypeApplication v0 ->
+        let collectTypeArgs =
+                \t2 -> \acc -> case (Strip.deannotateType t2) of
+                  Core.TypeApplication v1 ->
+                    let f2 = Core.applicationTypeFunction v1
+                        a2 = Core.applicationTypeArgument v1
+                    in (collectTypeArgs f2 (Lists.cons a2 acc))
+                  _ -> (t2, acc)
+            collected = collectTypeArgs (Core.TypeApplication v0) []
+            baseFun = Pairs.first collected
+            allArgs = Pairs.second collected
+        in (Eithers.bind (encodeType cx g baseFun) (\sfun -> Eithers.bind (Eithers.mapList (\a -> encodeType cx g a) allArgs) (\sargs -> Right (Utils.stapply sfun sargs))))
+      Core.TypeUnit -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+        Syntax.nameTypeValue = "Unit"})))
+      Core.TypeEither v0 ->
+        let lt = Core.eitherTypeLeft v0
+            rt = Core.eitherTypeRight v0
+        in (Eithers.bind (encodeType cx g lt) (\slt -> Eithers.bind (encodeType cx g rt) (\srt -> Right (Utils.stapply2 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+          Syntax.nameTypeValue = "Either"}))) slt srt))))
+      Core.TypeEffect v0 -> encodeType cx g v0
+      Core.TypeFunction v0 ->
+        let dom = Core.functionTypeDomain v0
+            cod = Core.functionTypeCodomain v0
+        in (Eithers.bind (encodeType cx g dom) (\sdom -> Eithers.bind (encodeType cx g cod) (\scod -> Right (Syntax.TypeFunction (Syntax.FunctionType {
+          Syntax.functionTypeParams = [
+            sdom],
+          Syntax.functionTypeRes = scod})))))
+      Core.TypeList v0 -> Eithers.bind (encodeType cx g v0) (\slt -> Right (Utils.stapply1 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+        Syntax.nameTypeValue = "scala.collection.immutable.Seq"}))) slt))
+      Core.TypeLiteral v0 -> case v0 of
+        Core.LiteralTypeBinary -> Right (Utils.stapply (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+          Syntax.nameTypeValue = "scala.Array"}))) [
+          Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Byte"}))])
+        Core.LiteralTypeBoolean -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+          Syntax.nameTypeValue = "scala.Boolean"})))
+        Core.LiteralTypeDecimal -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+          Syntax.nameTypeValue = "scala.math.BigDecimal"})))
+        Core.LiteralTypeFloat v1 -> case v1 of
+          Core.FloatTypeFloat32 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Float"})))
+          Core.FloatTypeFloat64 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Double"})))
+          _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported float type"))
+        Core.LiteralTypeInteger v1 -> case v1 of
+          Core.IntegerTypeBigint -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.math.BigInt"})))
+          Core.IntegerTypeInt8 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Byte"})))
+          Core.IntegerTypeInt16 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Short"})))
+          Core.IntegerTypeInt32 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Int"})))
+          Core.IntegerTypeInt64 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Long"})))
+          Core.IntegerTypeUint8 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Byte"})))
+          Core.IntegerTypeUint16 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Int"})))
+          Core.IntegerTypeUint32 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.Long"})))
+          Core.IntegerTypeUint64 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+            Syntax.nameTypeValue = "scala.math.BigInt"})))
+          _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported integer type"))
+        Core.LiteralTypeString -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+          Syntax.nameTypeValue = "scala.Predef.String"})))
+        _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported literal type"))
+      Core.TypeMap v0 ->
+        let kt = Core.mapTypeKeys v0
+            vt = Core.mapTypeValues v0
+        in (Eithers.bind (encodeType cx g kt) (\skt -> Eithers.bind (encodeType cx g vt) (\svt -> Right (Utils.stapply2 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+          Syntax.nameTypeValue = "scala.collection.immutable.Map"}))) skt svt))))
+      Core.TypeOptional v0 -> Eithers.bind (encodeType cx g v0) (\sot -> Right (Utils.stapply1 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+        Syntax.nameTypeValue = "scala.Option"}))) sot))
+      Core.TypePair v0 ->
+        let ft = Core.pairTypeFirst v0
+            st = Core.pairTypeSecond v0
+        in (Eithers.bind (encodeType cx g ft) (\sft -> Eithers.bind (encodeType cx g st) (\sst -> Right (Utils.stapply2 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+          Syntax.nameTypeValue = "Tuple2"}))) sft sst))))
+      Core.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type"))
+      Core.TypeSet v0 -> Eithers.bind (encodeType cx g v0) (\sst -> Right (Utils.stapply1 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+        Syntax.nameTypeValue = "scala.collection.immutable.Set"}))) sst))
+      Core.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type"))
+      Core.TypeWrap _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous wrap type"))
+      Core.TypeForall v0 ->
+        let v = Core.forallTypeParameter v0
+            body = Core.forallTypeBody v0
+        in (Eithers.bind (encodeType cx g body) (\sbody -> Right (Syntax.TypeLambda (Syntax.LambdaType {
+          Syntax.lambdaTypeTparams = [
+            Utils.stparam v],
+          Syntax.lambdaTypeTpe = sbody}))))
+      Core.TypeVariable v0 ->
+        let rawName = Core.unName v0
+            typeName = Logic.ifElse (Lists.elem 46 (Strings.toList rawName)) rawName (Formatting.capitalize rawName)
+        in (Right (Syntax.TypeVar (Syntax.VarType {
+          Syntax.varTypeName = Syntax.NameType {
+            Syntax.nameTypeValue = typeName}})))
+      _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported type"))
+
+-- | Encode a type definition as a Scala statement
+encodeTypeDefinition :: t0 -> t1 -> Packaging.TypeDefinition -> Either Errors.Error Syntax.Stat
+encodeTypeDefinition cx g td =
+
+      let name = Packaging.typeDefinitionName td
+          typ = Core.typeSchemeBody (Packaging.typeDefinitionBody td)
+          lname = Names.localNameOf name
+          tname = Syntax.NameType {
+                Syntax.nameTypeValue = lname}
+          dname = Syntax.NameData {
+                Syntax.nameDataValue = (Syntax.PredefString lname)}
+          freeVars =
+                  Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ))
+          tparams =
+                  Lists.map (\_v ->
+                    let vn = Formatting.capitalize (Core.unName _v)
+                    in Syntax.ParamType {
+                      Syntax.paramTypeMods = [],
+                      Syntax.paramTypeName = (Syntax.NameValue vn),
+                      Syntax.paramTypeTparams = [],
+                      Syntax.paramTypeTbounds = [],
+                      Syntax.paramTypeVbounds = [],
+                      Syntax.paramTypeCbounds = []}) freeVars
+      in case (Strip.deannotateType typ) of
+        Core.TypeForall v0 ->
+          let forallBody = Core.forallTypeBody v0
+              forallParam = Core.forallTypeParameter v0
+              collectForallParams =
+                      \t -> \acc -> case (Strip.deannotateType t) of
+                        Core.TypeForall v1 -> collectForallParams (Core.forallTypeBody v1) (Lists.cons (Core.forallTypeParameter v1) acc)
+                        _ -> (acc, t)
+              collected = collectForallParams forallBody [
+                    forallParam]
+              allForallParams = Lists.reverse (Pairs.first collected)
+              innerBody = Pairs.second collected
+              allTparams =
+                      Lists.map (\_v ->
+                        let vn = Formatting.capitalize (Core.unName _v)
+                        in Syntax.ParamType {
+                          Syntax.paramTypeMods = [],
+                          Syntax.paramTypeName = (Syntax.NameValue vn),
+                          Syntax.paramTypeTparams = [],
+                          Syntax.paramTypeTbounds = [],
+                          Syntax.paramTypeVbounds = [],
+                          Syntax.paramTypeCbounds = []}) allForallParams
+          in case (Strip.deannotateType innerBody) of
+            Core.TypeRecord v1 -> (\rt -> Eithers.bind (Eithers.mapList (\f -> fieldToParam cx g f) rt) (\params -> Right (Syntax.StatDefn (Syntax.DefnClass (Syntax.ClassDefn {
+              Syntax.classDefnMods = [
+                Syntax.ModCase],
+              Syntax.classDefnName = tname,
+              Syntax.classDefnTparams = allTparams,
+              Syntax.classDefnCtor = Syntax.PrimaryCtor {
+                Syntax.primaryCtorMods = [],
+                Syntax.primaryCtorName = (Syntax.NameValue ""),
+                Syntax.primaryCtorParamss = [
+                  params]},
+              Syntax.classDefnTemplate = Syntax.Template {
+                Syntax.templateEarly = [],
+                Syntax.templateInits = [],
+                Syntax.templateSelf = (Syntax.Self ()),
+                Syntax.templateStats = []}}))))) v1
+            Core.TypeUnion v1 -> (\g2 -> \rt -> Eithers.bind (Eithers.mapList (\f -> fieldToEnumCase cx g2 lname allTparams f) rt) (\cases -> Right (Syntax.StatDefn (Syntax.DefnEnum (Syntax.EnumDefn {
+              Syntax.enumDefnMods = [],
+              Syntax.enumDefnName = tname,
+              Syntax.enumDefnTparams = allTparams,
+              Syntax.enumDefnCtor = Syntax.PrimaryCtor {
+                Syntax.primaryCtorMods = [],
+                Syntax.primaryCtorName = (Syntax.NameValue ""),
+                Syntax.primaryCtorParamss = []},
+              Syntax.enumDefnTemplate = Syntax.Template {
+                Syntax.templateEarly = [],
+                Syntax.templateInits = [],
+                Syntax.templateSelf = (Syntax.Self ()),
+                Syntax.templateStats = cases}}))))) g v1
+            Core.TypeWrap v1 -> Eithers.bind (encodeType cx g v1) (\styp -> Right (Syntax.StatDefn (Syntax.DefnType (Syntax.TypeDefn {
+              Syntax.typeDefnMods = [],
+              Syntax.typeDefnName = tname,
+              Syntax.typeDefnTparams = allTparams,
+              Syntax.typeDefnBody = styp}))))
+            _ -> (\cx2 -> \g2 -> \typ2 ->
+              let mkAlias =
+                      \styp -> Right (Syntax.StatDefn (Syntax.DefnType (Syntax.TypeDefn {
+                        Syntax.typeDefnMods = [],
+                        Syntax.typeDefnName = Syntax.NameType {
+                          Syntax.nameTypeValue = lname},
+                        Syntax.typeDefnTparams = allTparams,
+                        Syntax.typeDefnBody = styp})))
+              in (Eithers.either (\_ -> mkAlias (Utils.stref "Any")) mkAlias (encodeType cx2 g2 typ2))) cx g innerBody
+        Core.TypeRecord v0 -> (\cx2 -> \g2 -> \rt2 -> Eithers.bind (Eithers.mapList (\f -> fieldToParam cx2 g2 f) rt2) (\params -> Right (Syntax.StatDefn (Syntax.DefnClass (Syntax.ClassDefn {
+          Syntax.classDefnMods = [
+            Syntax.ModCase],
+          Syntax.classDefnName = tname,
+          Syntax.classDefnTparams = tparams,
+          Syntax.classDefnCtor = Syntax.PrimaryCtor {
+            Syntax.primaryCtorMods = [],
+            Syntax.primaryCtorName = (Syntax.NameValue ""),
+            Syntax.primaryCtorParamss = [
+              params]},
+          Syntax.classDefnTemplate = Syntax.Template {
+            Syntax.templateEarly = [],
+            Syntax.templateInits = [],
+            Syntax.templateSelf = (Syntax.Self ()),
+            Syntax.templateStats = []}}))))) cx g v0
+        Core.TypeUnion v0 -> (\tparams2 -> \cx2 -> \g2 -> \rt2 -> Eithers.bind (Eithers.mapList (\f -> fieldToEnumCase cx2 g2 lname tparams2 f) rt2) (\cases -> Right (Syntax.StatDefn (Syntax.DefnEnum (Syntax.EnumDefn {
+          Syntax.enumDefnMods = [],
+          Syntax.enumDefnName = tname,
+          Syntax.enumDefnTparams = tparams2,
+          Syntax.enumDefnCtor = Syntax.PrimaryCtor {
+            Syntax.primaryCtorMods = [],
+            Syntax.primaryCtorName = (Syntax.NameValue ""),
+            Syntax.primaryCtorParamss = []},
+          Syntax.enumDefnTemplate = Syntax.Template {
+            Syntax.templateEarly = [],
+            Syntax.templateInits = [],
+            Syntax.templateSelf = (Syntax.Self ()),
+            Syntax.templateStats = cases}}))))) tparams cx g v0
+        Core.TypeWrap v0 -> Eithers.bind (encodeType cx g v0) (\styp -> Right (Syntax.StatDefn (Syntax.DefnType (Syntax.TypeDefn {
+          Syntax.typeDefnMods = [],
+          Syntax.typeDefnName = tname,
+          Syntax.typeDefnTparams = tparams,
+          Syntax.typeDefnBody = styp}))))
+        _ -> (\lname2 -> \tparams2 -> \cx2 -> \g2 -> \typ2 ->
+          let mkAlias =
+                  \styp -> Right (Syntax.StatDefn (Syntax.DefnType (Syntax.TypeDefn {
+                    Syntax.typeDefnMods = [],
+                    Syntax.typeDefnName = Syntax.NameType {
+                      Syntax.nameTypeValue = lname2},
+                    Syntax.typeDefnTparams = tparams2,
+                    Syntax.typeDefnBody = styp})))
+          in (Eithers.either (\_ -> mkAlias (Utils.stref "Any")) mkAlias (encodeType cx2 g2 typ2))) lname tparams cx g typ
+
+-- | Encode a parameter with its type annotation
+encodeTypedParam :: t0 -> t1 -> (Core.Name, Core.Type) -> Either Errors.Error Syntax.ParamData
+encodeTypedParam cx g pair =
+
+      let pname = Utils.scalaEscapeName (Names.localNameOf (Pairs.first pair))
+          pdom = Pairs.second pair
+      in (Eithers.bind (encodeType cx g pdom) (\sdom -> Right (Syntax.ParamData {
+        Syntax.paramDataMods = [],
+        Syntax.paramDataName = (Syntax.NameValue pname),
+        Syntax.paramDataDecltpe = (Just sdom),
+        Syntax.paramDataDefault = Nothing})))
+
+-- | Encode an untyped application term by first inferring types
+encodeUntypeApplicationTerm :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error Syntax.Data
+encodeUntypeApplicationTerm cx g term =
+    Eithers.bind (Inference.inferInGraphContext cx g term) (\result -> encodeTerm cx g (Typing.inferenceResultTerm result))
+
+-- | Extract the innermost body from a term
+extractBody :: Core.Term -> Core.Term
+extractBody t =
+    case (Strip.deannotateAndDetypeTerm t) of
+      Core.TermLambda v0 -> extractBody (Core.lambdaBody v0)
+      Core.TermTypeLambda v0 -> extractBody (Core.typeLambdaBody v0)
+      Core.TermTypeApplication v0 -> extractBody (Core.typeApplicationTermBody v0)
+      Core.TermLet v0 -> extractBody (Core.letBody v0)
+      _ -> t
+
+-- | Extract the final return type from a function type
+extractCodomain :: Core.Type -> Core.Type
+extractCodomain t =
+    case (Strip.deannotateType t) of
+      Core.TypeFunction v0 -> extractCodomain (Core.functionTypeCodomain v0)
+      Core.TypeForall v0 -> extractCodomain (Core.forallTypeBody v0)
+      _ -> t
+
+-- | Extract domain types from a function type
+extractDomains :: Core.Type -> [Core.Type]
+extractDomains t =
+    case (Strip.deannotateType t) of
+      Core.TypeFunction v0 -> Lists.cons (Core.functionTypeDomain v0) (extractDomains (Core.functionTypeCodomain v0))
+      Core.TypeForall v0 -> extractDomains (Core.forallTypeBody v0)
+      _ -> []
+
+-- | Extract let bindings from a term
+extractLetBindings :: Core.Term -> [Core.Binding]
+extractLetBindings t =
+    case (Strip.deannotateAndDetypeTerm t) of
+      Core.TermLambda v0 -> extractLetBindings (Core.lambdaBody v0)
+      Core.TermTypeLambda v0 -> extractLetBindings (Core.typeLambdaBody v0)
+      Core.TermTypeApplication v0 -> extractLetBindings (Core.typeApplicationTermBody v0)
+      Core.TermLet v0 -> Lists.concat2 (Core.letBindings v0) (extractLetBindings (Core.letBody v0))
+      _ -> []
+
+-- | Extract parameter names from a term
+extractParams :: Core.Term -> [Core.Name]
+extractParams t =
+    case (Strip.deannotateAndDetypeTerm t) of
+      Core.TermLambda v0 -> Lists.cons (Core.lambdaParameter v0) (extractParams (Core.lambdaBody v0))
+      Core.TermTypeLambda v0 -> extractParams (Core.typeLambdaBody v0)
+      Core.TermTypeApplication v0 -> extractParams (Core.typeApplicationTermBody v0)
+      Core.TermLet v0 -> extractParams (Core.letBody v0)
+      _ -> []
+
+-- | Convert a field type to a Scala enum case
+fieldToEnumCase :: t0 -> t1 -> String -> [Syntax.ParamType] -> Core.FieldType -> Either Errors.Error Syntax.Stat
+fieldToEnumCase cx g parentName tparams ft =
+
+      let fname = Utils.scalaEscapeEnumCaseName (Core.unName (Core.fieldTypeName ft))
+          ftyp = Core.fieldTypeType ft
+          caseName = Syntax.NameData {
+                Syntax.nameDataValue = (Syntax.PredefString fname)}
+          isUnit =
+                  case (Strip.deannotateType ftyp) of
+                    Core.TypeUnit -> True
+                    Core.TypeRecord v0 -> Equality.equal (Lists.length v0) 0
+                    _ -> False
+          parentType =
+                  Logic.ifElse (Lists.null tparams) (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+                    Syntax.nameTypeValue = parentName}))) (Syntax.TypeApply (Syntax.ApplyType {
+                    Syntax.applyTypeTpe = (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+                      Syntax.nameTypeValue = parentName}))),
+                    Syntax.applyTypeArgs = (Lists.map typeParamToTypeVar tparams)}))
+      in (Eithers.bind (encodeType cx g ftyp) (\sftyp -> Right (Syntax.StatDefn (Syntax.DefnEnumCase (Syntax.EnumCaseDefn {
+        Syntax.enumCaseDefnMods = [],
+        Syntax.enumCaseDefnName = caseName,
+        Syntax.enumCaseDefnTparams = [],
+        Syntax.enumCaseDefnCtor = Syntax.PrimaryCtor {
+          Syntax.primaryCtorMods = [],
+          Syntax.primaryCtorName = (Syntax.NameValue ""),
+          Syntax.primaryCtorParamss = [
+            Logic.ifElse isUnit [] [
+              Syntax.ParamData {
+                Syntax.paramDataMods = [],
+                Syntax.paramDataName = (Syntax.NameValue "value"),
+                Syntax.paramDataDecltpe = (Just sftyp),
+                Syntax.paramDataDefault = Nothing}]]},
+        Syntax.enumCaseDefnInits = [
+          Syntax.Init {
+            Syntax.initTpe = parentType,
+            Syntax.initName = (Syntax.NameValue ""),
+            Syntax.initArgss = []}]})))))
+
+-- | Convert a field type to a Scala parameter
+fieldToParam :: t0 -> t1 -> Core.FieldType -> Either Errors.Error Syntax.ParamData
+fieldToParam cx g ft =
+
+      let fname = Utils.scalaEscapeName (Core.unName (Core.fieldTypeName ft))
+          ftyp = Core.fieldTypeType ft
+      in (Eithers.bind (encodeType cx g ftyp) (\sftyp -> Right (Syntax.ParamData {
+        Syntax.paramDataMods = [],
+        Syntax.paramDataName = (Syntax.NameValue fname),
+        Syntax.paramDataDecltpe = (Just sftyp),
+        Syntax.paramDataDefault = Nothing})))
+
+-- | Find the domain type from annotations
+findDomain :: t0 -> Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.Error Core.Type
+findDomain cx g meta =
+    Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g meta)) (\r -> Optionals.cases r (Left (Errors.ErrorOther (Errors.OtherError "expected a typed term"))) (\t -> case (Strip.deannotateType t) of
+      Core.TypeFunction v0 -> Right (Core.functionTypeDomain v0)
+      _ -> Left (Errors.ErrorOther (Errors.OtherError "expected a function type"))))
+
+-- | Find import statements for the module
+findImports :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error [Syntax.Stat]
+findImports cx g mod =
+    Eithers.bind (Analysis.moduleDependencyModuleNames cx g False False True False mod) (\elImps -> Eithers.bind (Analysis.moduleDependencyModuleNames cx g False True False False mod) (\primImps -> Right (Lists.concat [
+      Lists.map toElImport (Sets.toList elImps),
+      (Lists.map toPrimImport (Sets.toList primImps))])))
+
+-- | Find the Scala domain type for a function from annotations
+findSdom :: t0 -> Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.Error (Maybe Syntax.Type)
+findSdom cx g meta =
+    Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g meta)) (\mtyp -> Optionals.cases mtyp (Right Nothing) (\t -> case (Strip.deannotateType t) of
+      Core.TypeFunction v0 ->
+        let dom = Core.functionTypeDomain v0
+        in (Eithers.bind (encodeType cx g dom) (\sdom -> Right (Just sdom)))
+      Core.TypeForall v0 -> case (Strip.deannotateType (Core.forallTypeBody v0)) of
+        Core.TypeFunction v1 ->
+          let dom2 = Core.functionTypeDomain v1
+          in (Eithers.bind (encodeType cx g dom2) (\sdom2 -> Right (Just sdom2)))
+        _ -> Right Nothing
+      _ -> Eithers.bind (encodeType cx g t) (\st -> Right (Just st))))
+
+-- | Convert a Hydra module to Scala source code
+moduleToScala :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error (M.Map String String)
+moduleToScala mod defs cx g =
+    Eithers.bind (constructModule cx g mod defs) (\pkg ->
+      let s = Serialization.printExpr (Serialization.parenthesize (Serde.pkgToExpr pkg))
+      in (Right (Maps.singleton (Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "scala") (Packaging.moduleName mod)) s)))
+
+-- | Strip wrap eliminations from terms (newtypes are erased in Scala)
+stripWrapEliminations :: Core.Term -> Core.Term
+stripWrapEliminations t =
+    case (Strip.deannotateAndDetypeTerm t) of
+      Core.TermApplication v0 ->
+        let appFun = Core.applicationFunction v0
+            appArg = Core.applicationArgument v0
+        in case (Strip.deannotateAndDetypeTerm appFun) of
+          Core.TermUnwrap _ -> stripWrapEliminations appArg
+          Core.TermApplication v1 ->
+            let innerFun = Core.applicationFunction v1
+                innerArg = Core.applicationArgument v1
+            in case (Strip.deannotateAndDetypeTerm innerFun) of
+              Core.TermUnwrap _ -> stripWrapEliminations (Core.TermApplication (Core.Application {
+                Core.applicationFunction = innerArg,
+                Core.applicationArgument = appArg}))
+              _ -> t
+          _ -> t
+      _ -> t
+
+-- | Create an element import statement
+toElImport :: Packaging.ModuleName -> Syntax.Stat
+toElImport ns =
+    Syntax.StatImportExport (Syntax.ImportExportStatImport (Syntax.Import {
+      Syntax.importImporters = [
+        Syntax.Importer {
+          Syntax.importerRef = (Syntax.RefDataName (Syntax.NameData {
+            Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." (Packaging.unModuleName ns))))})),
+          Syntax.importerImportees = [
+            Syntax.ImporteeWildcard]}]}))
+
+-- | Create a primitive import statement
+toPrimImport :: Packaging.ModuleName -> Syntax.Stat
+toPrimImport ns =
+    Syntax.StatImportExport (Syntax.ImportExportStatImport (Syntax.Import {
+      Syntax.importImporters = [
+        Syntax.Importer {
+          Syntax.importerRef = (Syntax.RefDataName (Syntax.NameData {
+            Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." (Packaging.unModuleName ns))))})),
+          Syntax.importerImportees = []}]}))
+
+-- | Convert a type parameter to a type variable reference
+typeParamToTypeVar :: Syntax.ParamType -> Syntax.Type
+typeParamToTypeVar tp =
+
+      let n = Syntax.paramTypeName tp
+          s =
+                  case n of
+                    Syntax.NameValue v0 -> v0
+                    _ -> ""
+      in (Syntax.TypeVar (Syntax.VarType {
+        Syntax.varTypeName = Syntax.NameType {
+          Syntax.nameTypeValue = s}}))
diff --git a/src/main/haskell/Hydra/Scala/Language.hs b/src/main/haskell/Hydra/Scala/Language.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Scala/Language.hs
@@ -0,0 +1,226 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Language constraints and reserved words for Scala
+
+module Hydra.Scala.Language where
+
+import qualified Hydra.Ast as Ast
+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.File as ErrorFile
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Error.System as ErrorSystem
+import qualified Hydra.Errors as Errors
+import qualified Hydra.File as File
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Lexical as Lexical
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets
+import qualified Hydra.Packaging as Packaging
+import qualified Hydra.Parsing as Parsing
+import qualified Hydra.Paths as Paths
+import qualified Hydra.Query as Query
+import qualified Hydra.Relational as Relational
+import qualified Hydra.System as System
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Time as Time
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+import qualified Data.Set as S
+
+-- | Language constraints for Scala
+scalaLanguage :: Coders.Language
+scalaLanguage =
+    Coders.Language {
+      Coders.languageName = (Coders.LanguageName "hydra.scala"),
+      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.LanguageFeatureNestedPolymorphicLetBindings]),
+      Coders.languageCaseConventions = Coders.CaseConventions {
+        Coders.caseConventionsConstant = Util.CaseConventionUpperSnake,
+        Coders.caseConventionsDirectory = Util.CaseConventionCamel,
+        Coders.caseConventionsEnumValue = Util.CaseConventionPascal,
+        Coders.caseConventionsField = Util.CaseConventionCamel,
+        Coders.caseConventionsFile = Util.CaseConventionCamel,
+        Coders.caseConventionsModule = Util.CaseConventionCamel,
+        Coders.caseConventionsTerm = Util.CaseConventionCamel,
+        Coders.caseConventionsTermVariable = Util.CaseConventionCamel,
+        Coders.caseConventionsType = Util.CaseConventionPascal,
+        Coders.caseConventionsTypeVariable = Util.CaseConventionPascal},
+      Coders.languageDefaultFileExtension = (File.FileExtension "scala")}
+  where
+    literalVariants =
+        Sets.fromList [
+          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.IntegerTypeUint8,
+          Core.IntegerTypeUint16,
+          Core.IntegerTypeUint32,
+          Core.IntegerTypeUint64]
+    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.TypeVariantList,
+          Variants.TypeVariantLiteral,
+          Variants.TypeVariantMap,
+          Variants.TypeVariantOptional,
+          Variants.TypeVariantPair,
+          Variants.TypeVariantRecord,
+          Variants.TypeVariantSet,
+          Variants.TypeVariantUnion,
+          Variants.TypeVariantUnit,
+          Variants.TypeVariantForall,
+          Variants.TypeVariantVariable,
+          Variants.TypeVariantVoid,
+          Variants.TypeVariantWrap]
+    typePredicate = \_ -> True
+
+-- | A set of reserved words in Scala
+scalaReservedWords :: S.Set String
+scalaReservedWords =
+    Sets.fromList (Lists.concat [
+      keywords,
+      classNames])
+  where
+    keywords =
+        [
+          "abstract",
+          "case",
+          "catch",
+          "class",
+          "def",
+          "do",
+          "else",
+          "end",
+          "enum",
+          "export",
+          "extends",
+          "false",
+          "final",
+          "finally",
+          "for",
+          "forSome",
+          "given",
+          "if",
+          "implicit",
+          "import",
+          "lazy",
+          "macro",
+          "match",
+          "new",
+          "null",
+          "object",
+          "override",
+          "package",
+          "private",
+          "protected",
+          "return",
+          "sealed",
+          "super",
+          "then",
+          "this",
+          "throw",
+          "trait",
+          "true",
+          "try",
+          "type",
+          "val",
+          "var",
+          "while",
+          "with",
+          "yield"]
+    classNames =
+        [
+          "Any",
+          "AnyVal",
+          "App",
+          "Array",
+          "Boolean",
+          "Byte",
+          "Char",
+          "Console",
+          "DelayedInit",
+          "Double",
+          "DummyExplicit",
+          "Dynamic",
+          "Enumeration",
+          "Equals",
+          "Float",
+          "Function",
+          "Int",
+          "Long",
+          "MatchError",
+          "None",
+          "Nothing",
+          "Null",
+          "Option",
+          "PartialFunction",
+          "Predef",
+          "Product",
+          "Proxy",
+          "SerialVersionUID",
+          "Short",
+          "Singleton",
+          "Some",
+          "Specializable",
+          "StringContext",
+          "Symbol",
+          "Unit",
+          "ValueOf"]
diff --git a/src/main/haskell/Hydra/Scala/Serde.hs b/src/main/haskell/Hydra/Scala/Serde.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Scala/Serde.hs
@@ -0,0 +1,435 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Serialization functions for converting Scala AST to abstract expressions
+
+module Hydra.Scala.Serde where
+
+import qualified Hydra.Ast as Ast
+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.File as ErrorFile
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Error.System as ErrorSystem
+import qualified Hydra.Errors as Errors
+import qualified Hydra.File as File
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.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.Math as Math
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
+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.Scala.Syntax as Syntax
+import qualified Hydra.Serialization as Serialization
+import qualified Hydra.System as System
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Time as Time
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.Variants as Variants
+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
+import qualified Data.Scientific as Sci
+
+-- | Convert a case clause to an expression
+caseToExpr :: Syntax.Case -> Ast.Expr
+caseToExpr c =
+
+      let pat = Syntax.casePat c
+          term = Syntax.caseBody c
+      in (Serialization.spaceSep [
+        Serialization.cst "case",
+        (patToExpr pat),
+        (Serialization.cst "=>"),
+        (termToExpr term)])
+
+-- | Convert a function-data lambda to an expression
+dataFunctionToExpr :: Syntax.FunctionData -> Ast.Expr
+dataFunctionToExpr f =
+
+      let params = Syntax.functionDataParams f
+          body = Syntax.functionDataBody f
+          bodyExpr = termToExpr body
+          bodyLen = Serialization.expressionLength bodyExpr
+      in (Logic.ifElse (Equality.gt bodyLen 60) (Serialization.noSep [
+        Serialization.parenListAdaptive (Lists.map dataParamToExpr params),
+        (Serialization.cst " =>\n  "),
+        bodyExpr]) (Serialization.spaceSep [
+        Serialization.parenListAdaptive (Lists.map dataParamToExpr params),
+        (Serialization.cst "=>"),
+        bodyExpr]))
+
+-- | Convert a data name to an expression
+dataNameToExpr :: Syntax.NameData -> Ast.Expr
+dataNameToExpr dn = Serialization.cst (Syntax.unPredefString (Syntax.nameDataValue dn))
+
+-- | Convert a data parameter to an expression
+dataParamToExpr :: Syntax.ParamData -> Ast.Expr
+dataParamToExpr dp =
+
+      let name = Syntax.paramDataName dp
+          stype = Syntax.paramDataDecltpe dp
+      in (Serialization.noSep (Optionals.cat [
+        Optionals.pure (nameToExpr name),
+        (Optionals.map (\t -> Serialization.spaceSep [
+          Serialization.cst ":",
+          (typeToExpr t)]) stype)]))
+
+-- | Convert a data reference to an expression
+dataRefToExpr :: Syntax.RefData -> Ast.Expr
+dataRefToExpr ref =
+    case ref of
+      Syntax.RefDataName v0 -> dataNameToExpr v0
+      Syntax.RefDataSelect v0 -> dataSelectToExpr v0
+
+-- | Convert a data select to an expression
+dataSelectToExpr :: Syntax.SelectData -> Ast.Expr
+dataSelectToExpr sel =
+
+      let arg = Syntax.selectDataQual sel
+          name = Syntax.selectDataName sel
+      in (Serialization.ifx dotOp (termToExpr arg) (termToExpr (Syntax.DataRef (Syntax.RefDataName name))))
+
+-- | Convert a definition to an expression
+defnToExpr :: Syntax.Defn -> Ast.Expr
+defnToExpr def =
+    case def of
+      Syntax.DefnDef v0 ->
+        let name = Syntax.defDefnName v0
+            tparams = Syntax.defDefnTparams v0
+            paramss = Syntax.defDefnParamss v0
+            scod = Syntax.defDefnDecltpe v0
+            body = Syntax.defDefnBody v0
+            tparamsExpr =
+                    Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams)))
+            scodExpr =
+                    Optionals.map (\t -> Serialization.spaceSep [
+                      Serialization.cst ":",
+                      (typeToExpr t)]) scod
+            paramssExprs = Lists.map (\ps -> Serialization.parenListAdaptive (Lists.map dataParamToExpr ps)) paramss
+            nameAndParams =
+                    Serialization.noSep (Optionals.cat (Lists.concat [
+                      [
+                        Optionals.pure (dataNameToExpr name)],
+                      [
+                        tparamsExpr],
+                      (Lists.map (\pe -> Optionals.pure pe) paramssExprs),
+                      [
+                        scodExpr]]))
+            bodyExpr = termToExpr body
+            defSig =
+                    Serialization.spaceSep [
+                      Serialization.cst "def",
+                      nameAndParams,
+                      (Serialization.cst "=")]
+            bodyLen = Serialization.expressionLength bodyExpr
+        in (Logic.ifElse (Equality.gt bodyLen 80) (Serialization.noSep [
+          defSig,
+          (Serialization.cst "\n  "),
+          bodyExpr]) (Serialization.spaceSep [
+          defSig,
+          bodyExpr]))
+      Syntax.DefnType v0 ->
+        let name = Syntax.typeDefnName v0
+            tparams = Syntax.typeDefnTparams v0
+            body = Syntax.typeDefnBody v0
+        in (Serialization.spaceSep (Optionals.cat [
+          Optionals.pure (Serialization.cst "type"),
+          (Optionals.pure (typeNameToExpr name)),
+          (Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams)))),
+          (Optionals.pure (Serialization.cst "=")),
+          (Optionals.pure (typeToExpr body))]))
+      Syntax.DefnVal v0 ->
+        let mods = Syntax.valDefnMods v0
+            pats = Syntax.valDefnPats v0
+            typ = Syntax.valDefnDecltpe v0
+            rhs = Syntax.valDefnRhs v0
+            nameStr =
+                    Optionals.fromOptional "" (Optionals.map (\firstPat ->
+                      let patName =
+                              case firstPat of
+                                Syntax.PatVar v1 -> Syntax.varPatName v1
+                      in (Syntax.unPredefString (Syntax.nameDataValue patName))) (Lists.maybeHead pats))
+            nameAndType =
+                    Optionals.cases typ (Serialization.cst nameStr) (\t -> Serialization.spaceSep [
+                      Serialization.cst (Strings.cat2 nameStr ":"),
+                      (typeToExpr t)])
+            valKeyword = Logic.ifElse (Lists.null mods) "val" "lazy val"
+        in (Serialization.spaceSep [
+          Serialization.cst valKeyword,
+          nameAndType,
+          (Serialization.cst "="),
+          (termToExpr rhs)])
+      Syntax.DefnClass v0 ->
+        let mods = Syntax.classDefnMods v0
+            name = Syntax.classDefnName v0
+            tparams = Syntax.classDefnTparams v0
+            ctor = Syntax.classDefnCtor v0
+            paramss = Syntax.primaryCtorParamss ctor
+            tparamsExpr =
+                    Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams)))
+            paramsExpr =
+                    Logic.ifElse (Lists.null paramss) Nothing (Optionals.pure (Serialization.parenListAdaptive (Lists.map dataParamToExpr (Lists.concat paramss))))
+            nameAndParams =
+                    Serialization.noSep (Optionals.cat [
+                      Optionals.pure (typeNameToExpr name),
+                      tparamsExpr,
+                      paramsExpr])
+        in (Serialization.spaceSep (Lists.concat [
+          Lists.map modToExpr mods,
+          [
+            Serialization.cst "class",
+            nameAndParams]]))
+      Syntax.DefnEnum v0 ->
+        let name = Syntax.enumDefnName v0
+            tparams = Syntax.enumDefnTparams v0
+            template = Syntax.enumDefnTemplate v0
+            stats = Syntax.templateStats template
+            enumHeader =
+                    Serialization.spaceSep [
+                      Serialization.cst "enum",
+                      (Serialization.noSep (Optionals.cat [
+                        Optionals.pure (typeNameToExpr name),
+                        (Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams))))])),
+                      (Serialization.cst ":")]
+            enumCases =
+                    Lists.map (\s -> Serialization.spaceSep [
+                      Serialization.cst "  ",
+                      (statToExpr s)]) stats
+        in (Serialization.newlineSep (Lists.concat [
+          [
+            enumHeader],
+          enumCases]))
+      Syntax.DefnEnumCase v0 ->
+        let name = Syntax.enumCaseDefnName v0
+            ctor = Syntax.enumCaseDefnCtor v0
+            inits = Syntax.enumCaseDefnInits v0
+            paramss = Syntax.primaryCtorParamss ctor
+            allParams = Lists.concat paramss
+            params =
+                    Logic.ifElse (Lists.null allParams) (Serialization.cst "") (Serialization.parenListAdaptive (Lists.map dataParamToExpr allParams))
+            extendsClause =
+                    Logic.ifElse (Lists.null inits) (Serialization.cst "") (Serialization.spaceSep [
+                      Serialization.cst "extends",
+                      (Serialization.commaSep Serialization.inlineStyle (Lists.map initToExpr inits))])
+        in (Serialization.spaceSep [
+          Serialization.cst "case",
+          (Serialization.noSep [
+            dataNameToExpr name,
+            params]),
+          extendsClause])
+
+-- | The dot operator for member access
+dotOp :: Ast.Op
+dotOp =
+    Ast.Op {
+      Ast.opSymbol = (Ast.Symbol "."),
+      Ast.opPadding = Ast.Padding {
+        Ast.paddingLeft = Ast.WsNone,
+        Ast.paddingRight = Ast.WsNone},
+      Ast.opPrecedence = (Ast.Precedence 0),
+      Ast.opAssociativity = Ast.AssociativityLeft}
+
+-- | The function arrow operator (=>)
+functionArrowOp :: Ast.Op
+functionArrowOp = Serialization.op "=>" (Math.negate 1) Ast.AssociativityRight
+
+-- | Convert an import/export statement to an expression
+importExportStatToExpr :: Syntax.ImportExportStat -> Ast.Expr
+importExportStatToExpr ie =
+    case ie of
+      Syntax.ImportExportStatImport v0 ->
+        let importers = Syntax.importImporters v0
+        in (Serialization.newlineSep (Lists.map importerToExpr importers))
+
+-- | Convert an importer to an expression
+importerToExpr :: Syntax.Importer -> Ast.Expr
+importerToExpr imp =
+
+      let ref = Syntax.importerRef imp
+          importees = Syntax.importerImportees imp
+          refName =
+                  case ref of
+                    Syntax.RefDataName v0 -> Syntax.unPredefString (Syntax.nameDataValue v0)
+          forImportees =
+                  Logic.ifElse (Lists.null importees) (Serialization.cst "") (Logic.ifElse (Equality.equal (Lists.length importees) 1) (Optionals.fromOptional (Serialization.cst "") (Optionals.map (\firstImp -> Serialization.noSep [
+                    Serialization.cst ".",
+                    case firstImp of
+                      Syntax.ImporteeWildcard -> Serialization.cst "*"
+                      Syntax.ImporteeName v0 -> Serialization.cst (case (Syntax.nameImporteeName v0) of
+                        Syntax.NameValue v1 -> v1)]) (Lists.maybeHead importees))) (Serialization.noSep [
+                    Serialization.cst ".",
+                    (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map (\it -> case it of
+                      Syntax.ImporteeWildcard -> Serialization.cst "*"
+                      Syntax.ImporteeName v0 -> Serialization.cst (case (Syntax.nameImporteeName v0) of
+                        Syntax.NameValue v1 -> v1)) importees))]))
+      in (Serialization.spaceSep [
+        Serialization.cst "import",
+        (Serialization.noSep [
+          Serialization.cst refName,
+          forImportees])])
+
+-- | Convert an init to an expression
+initToExpr :: Syntax.Init -> Ast.Expr
+initToExpr init = typeToExpr (Syntax.initTpe init)
+
+-- | Convert a literal to an expression
+litToExpr :: Syntax.Lit -> Ast.Expr
+litToExpr lit =
+    case lit of
+      Syntax.LitBoolean v0 -> Serialization.cst (Logic.ifElse v0 "true" "false")
+      Syntax.LitByte v0 -> Serialization.cst (Strings.cat2 (Literals.showInt8 v0) ".toByte")
+      Syntax.LitShort v0 -> Serialization.cst (Strings.cat2 (Literals.showInt16 v0) ".toShort")
+      Syntax.LitInt v0 -> Serialization.cst (Literals.showInt32 v0)
+      Syntax.LitLong v0 -> Serialization.cst (Strings.cat2 (Literals.showInt64 v0) "L")
+      Syntax.LitFloat v0 -> Serialization.cst (scalaFloatLiteralText "Float" "f" (Literals.showFloat32 v0))
+      Syntax.LitDouble v0 -> Serialization.cst (scalaFloatLiteralText "Double" "" (Literals.showFloat64 v0))
+      Syntax.LitUnit -> Serialization.cst "()"
+      Syntax.LitString v0 -> Serialization.cst (Strings.cat2 "\"" (Strings.cat2 (Serde.escapeJavaString v0) "\""))
+      Syntax.LitBytes v0 -> Serialization.cst (Strings.cat2 "Array[Byte](" (Strings.cat2 (Strings.intercalate ", " (Lists.map (\b -> Strings.cat2 (Literals.showInt32 b) ".toByte") v0)) ")"))
+      _ -> Serialization.cst "TODO:literal"
+
+-- | The match operator
+matchOp :: Ast.Op
+matchOp =
+    Ast.Op {
+      Ast.opSymbol = (Ast.Symbol "match"),
+      Ast.opPadding = Ast.Padding {
+        Ast.paddingLeft = Ast.WsSpace,
+        Ast.paddingRight = (Ast.WsBreakAndIndent "  ")},
+      Ast.opPrecedence = (Ast.Precedence 0),
+      Ast.opAssociativity = Ast.AssociativityNone}
+
+-- | Convert a modifier to an expression
+modToExpr :: Syntax.Mod -> Ast.Expr
+modToExpr m =
+    case m of
+      Syntax.ModCase -> Serialization.cst "case"
+      Syntax.ModSealed -> Serialization.cst "sealed"
+      Syntax.ModAbstract -> Serialization.cst "abstract"
+      Syntax.ModFinal -> Serialization.cst "final"
+      Syntax.ModOverride -> Serialization.cst "override"
+      Syntax.ModImplicit -> Serialization.cst "implicit"
+      Syntax.ModLazy -> Serialization.cst "lazy"
+      Syntax.ModPrivate _ -> Serialization.cst "private"
+      Syntax.ModProtected _ -> Serialization.cst "protected"
+
+-- | Convert a name to an expression
+nameToExpr :: Syntax.Name -> Ast.Expr
+nameToExpr name =
+    case name of
+      Syntax.NameValue v0 -> Serialization.cst v0
+
+-- | Convert a pattern to an expression
+patToExpr :: Syntax.Pat -> Ast.Expr
+patToExpr pat =
+    case pat of
+      Syntax.PatExtract v0 ->
+        let fun = Syntax.extractPatFun v0
+            args = Syntax.extractPatArgs v0
+        in (Logic.ifElse (Lists.null args) (termToExpr fun) (Serialization.noSep [
+          termToExpr fun,
+          (Serialization.parenListAdaptive (Lists.map patToExpr args))]))
+      Syntax.PatVar v0 -> dataNameToExpr (Syntax.varPatName v0)
+      Syntax.PatWildcard -> Serialization.cst "_"
+
+-- | Convert a package to an expression
+pkgToExpr :: Syntax.Pkg -> Ast.Expr
+pkgToExpr pkg =
+
+      let name = Syntax.pkgName pkg
+          stats = Syntax.pkgStats pkg
+          package =
+                  Serialization.spaceSep [
+                    Serialization.cst "package",
+                    (dataNameToExpr name)]
+      in (Serialization.doubleNewlineSep (Lists.concat [
+        [
+          package],
+        (Lists.map statToExpr stats)]))
+
+scalaFloatLiteralText :: String -> String -> String -> String
+scalaFloatLiteralText prefix suffix s =
+    Logic.ifElse (Equality.equal s "NaN") (Strings.cat2 prefix ".NaN") (Logic.ifElse (Equality.equal s "Infinity") (Strings.cat2 prefix ".PositiveInfinity") (Logic.ifElse (Equality.equal s "-Infinity") (Strings.cat2 prefix ".NegativeInfinity") (Strings.cat2 s suffix)))
+
+-- | Convert a statement to an expression
+statToExpr :: Syntax.Stat -> Ast.Expr
+statToExpr stat =
+    case stat of
+      Syntax.StatTerm v0 -> termToExpr v0
+      Syntax.StatDefn v0 -> defnToExpr v0
+      Syntax.StatImportExport v0 -> importExportStatToExpr v0
+
+-- | Convert a term to an expression
+termToExpr :: Syntax.Data -> Ast.Expr
+termToExpr term =
+    case term of
+      Syntax.DataLit v0 -> litToExpr v0
+      Syntax.DataRef v0 -> dataRefToExpr v0
+      Syntax.DataApply v0 ->
+        let fun = Syntax.applyDataFun v0
+            args = Syntax.applyDataArgs v0
+        in (Serialization.noSep [
+          termToExpr fun,
+          (Serialization.parenListAdaptive (Lists.map termToExpr args))])
+      Syntax.DataAssign v0 ->
+        let lhs = Syntax.assignDataLhs v0
+            rhs = Syntax.assignDataRhs v0
+        in (Serialization.spaceSep [
+          termToExpr lhs,
+          (Serialization.cst "->"),
+          (termToExpr rhs)])
+      Syntax.DataTuple v0 -> Serialization.parenListAdaptive (Lists.map termToExpr (Syntax.tupleDataArgs v0))
+      Syntax.DataMatch v0 ->
+        let expr = Syntax.matchDataExpr v0
+            mCases = Syntax.matchDataCases v0
+        in (Serialization.ifx matchOp (termToExpr expr) (Serialization.newlineSep (Lists.map caseToExpr mCases)))
+      Syntax.DataFunction v0 -> dataFunctionToExpr v0
+      Syntax.DataBlock v0 ->
+        let stats = Syntax.blockDataStats v0
+        in (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.newlineSep (Lists.map statToExpr stats)))
+
+-- | Convert a type name to an expression
+typeNameToExpr :: Syntax.NameType -> Ast.Expr
+typeNameToExpr tn = Serialization.cst (Syntax.nameTypeValue tn)
+
+-- | Convert a type parameter to an expression
+typeParamToExpr :: Syntax.ParamType -> Ast.Expr
+typeParamToExpr tp = nameToExpr (Syntax.paramTypeName tp)
+
+-- | Convert a type to an expression
+typeToExpr :: Syntax.Type -> Ast.Expr
+typeToExpr typ =
+    case typ of
+      Syntax.TypeRef v0 -> case v0 of
+        Syntax.RefTypeName v1 -> typeNameToExpr v1
+      Syntax.TypeApply v0 ->
+        let fun = Syntax.applyTypeTpe v0
+            args = Syntax.applyTypeArgs v0
+        in (Serialization.noSep [
+          typeToExpr fun,
+          (Serialization.bracketList Serialization.inlineStyle (Lists.map typeToExpr args))])
+      Syntax.TypeFunction v0 ->
+        let cod = Syntax.functionTypeRes v0
+            dom = Optionals.fromOptional cod (Lists.maybeHead (Syntax.functionTypeParams v0))
+        in (Serialization.ifx functionArrowOp (typeToExpr dom) (typeToExpr cod))
+      Syntax.TypeLambda v0 ->
+        let params = Syntax.lambdaTypeTparams v0
+            body = Syntax.lambdaTypeTpe v0
+        in (Serialization.noSep [
+          typeToExpr body,
+          (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr params))])
+      Syntax.TypeVar v0 -> typeNameToExpr (Syntax.varTypeName v0)
diff --git a/src/main/haskell/Hydra/Scala/Syntax.hs b/src/main/haskell/Hydra/Scala/Syntax.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Scala/Syntax.hs
@@ -0,0 +1,2128 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | A Scala syntax model for Hydra, anchored on Scalameta (https://scalameta.org). Departs from Scalameta where Hydra's needs differ: Term is renamed to Data, the FunctionType/FunctionData wrappers are flattened, and arms Hydra never emits (xml literals, quasiquote/macro forms) are omitted.
+
+module Hydra.Scala.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
+import qualified Data.Int as I
+
+-- | A wrapper for strings used in scala.Predef contexts.
+newtype PredefString =
+  PredefString {
+    unPredefString :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_PredefString = Core.Name "hydra.scala.syntax.PredefString"
+
+-- | A Scala 2 symbol literal (corresponds to scala.Symbol).
+data ScalaSymbol =
+  ScalaSymbol {
+    scalaSymbolName :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_ScalaSymbol = Core.Name "hydra.scala.syntax.ScalaSymbol"
+
+_ScalaSymbol_name = Core.Name "name"
+
+-- | The root of the Scalameta tree hierarchy. Each arm names a major AST category.
+data Tree =
+  TreeRef Ref |
+  TreeStat Stat |
+  TreeType Type |
+  TreeBounds TypeBounds |
+  TreePat Pat |
+  TreeMember Member |
+  TreeCtor Ctor |
+  TreeTemplate Template |
+  TreeMod Mod |
+  TreeEnumerator Enumerator |
+  TreeImporter Importer |
+  TreeImportee Importee |
+  TreeCaseTree CaseTree |
+  TreeSource Source
+  deriving (Eq, Ord, Read, Show)
+
+_Tree = Core.Name "hydra.scala.syntax.Tree"
+
+_Tree_ref = Core.Name "ref"
+
+_Tree_stat = Core.Name "stat"
+
+_Tree_type = Core.Name "type"
+
+_Tree_bounds = Core.Name "bounds"
+
+_Tree_pat = Core.Name "pat"
+
+_Tree_member = Core.Name "member"
+
+_Tree_ctor = Core.Name "ctor"
+
+_Tree_template = Core.Name "template"
+
+_Tree_mod = Core.Name "mod"
+
+_Tree_enumerator = Core.Name "enumerator"
+
+_Tree_importer = Core.Name "importer"
+
+_Tree_importee = Core.Name "importee"
+
+_Tree_caseTree = Core.Name "caseTree"
+
+_Tree_source = Core.Name "source"
+
+data Ref =
+  RefName Name |
+  RefInit Init
+  deriving (Eq, Ord, Read, Show)
+
+_Ref = Core.Name "hydra.scala.syntax.Ref"
+
+_Ref_name = Core.Name "name"
+
+_Ref_init = Core.Name "init"
+
+data Stat =
+  StatTerm Data |
+  StatDecl Decl |
+  StatDefn Defn |
+  StatImportExport ImportExportStat
+  deriving (Eq, Ord, Read, Show)
+
+_Stat = Core.Name "hydra.scala.syntax.Stat"
+
+_Stat_term = Core.Name "term"
+
+_Stat_decl = Core.Name "decl"
+
+_Stat_defn = Core.Name "defn"
+
+_Stat_importExport = Core.Name "importExport"
+
+data Name =
+  NameValue String |
+  NameAnonymous |
+  NameIndeterminate PredefString
+  deriving (Eq, Ord, Read, Show)
+
+_Name = Core.Name "hydra.scala.syntax.Name"
+
+_Name_value = Core.Name "value"
+
+_Name_anonymous = Core.Name "anonymous"
+
+_Name_indeterminate = Core.Name "indeterminate"
+
+data Lit =
+  LitNull |
+  LitInt Int |
+  LitDouble Double |
+  LitFloat Float |
+  LitByte I.Int8 |
+  LitShort I.Int16 |
+  LitChar Int |
+  LitLong I.Int64 |
+  LitBoolean Bool |
+  LitUnit |
+  LitString String |
+  LitBytes [Int] |
+  LitSymbol ScalaSymbol
+  deriving (Eq, Ord, Read, Show)
+
+_Lit = Core.Name "hydra.scala.syntax.Lit"
+
+_Lit_null = Core.Name "null"
+
+_Lit_int = Core.Name "int"
+
+_Lit_double = Core.Name "double"
+
+_Lit_float = Core.Name "float"
+
+_Lit_byte = Core.Name "byte"
+
+_Lit_short = Core.Name "short"
+
+_Lit_char = Core.Name "char"
+
+_Lit_long = Core.Name "long"
+
+_Lit_boolean = Core.Name "boolean"
+
+_Lit_unit = Core.Name "unit"
+
+_Lit_string = Core.Name "string"
+
+_Lit_bytes = Core.Name "bytes"
+
+_Lit_symbol = Core.Name "symbol"
+
+data Data =
+  DataLit Lit |
+  DataRef RefData |
+  DataInterpolate InterpolateData |
+  DataApply ApplyData |
+  DataApplyUsing ApplyUsingData |
+  DataApplyType ApplyTypeData |
+  DataAssign AssignData |
+  DataReturn ReturnData |
+  DataThrow ThrowData |
+  DataAscribe AscribeData |
+  DataAnnotate AnnotateData |
+  DataTuple TupleData |
+  DataBlock BlockData |
+  DataEndMarker EndMarkerData |
+  DataIf IfData |
+  DataMatch MatchData |
+  DataTry TryData |
+  DataTryWithHandler TryWithHandlerData |
+  DataFunction FunctionData |
+  DataContextFunction ContextFunctionData |
+  DataPolyFunction PolyFunctionData |
+  DataPartialFunction PartialFunctionData |
+  DataWhile WhileData |
+  DataDo DoData |
+  DataFor ForData |
+  DataForYield ForYieldData |
+  DataNew NewData |
+  DataNewAnonymous NewAnonymousData |
+  DataPlaceholder |
+  DataEta EtaData |
+  DataRepeated RepeatedData |
+  DataParam ParamData
+  deriving (Eq, Ord, Read, Show)
+
+_Data = Core.Name "hydra.scala.syntax.Data"
+
+_Data_lit = Core.Name "lit"
+
+_Data_ref = Core.Name "ref"
+
+_Data_interpolate = Core.Name "interpolate"
+
+_Data_apply = Core.Name "apply"
+
+_Data_applyUsing = Core.Name "applyUsing"
+
+_Data_applyType = Core.Name "applyType"
+
+_Data_assign = Core.Name "assign"
+
+_Data_return = Core.Name "return"
+
+_Data_throw = Core.Name "throw"
+
+_Data_ascribe = Core.Name "ascribe"
+
+_Data_annotate = Core.Name "annotate"
+
+_Data_tuple = Core.Name "tuple"
+
+_Data_block = Core.Name "block"
+
+_Data_endMarker = Core.Name "endMarker"
+
+_Data_if = Core.Name "if"
+
+_Data_match = Core.Name "match"
+
+_Data_try = Core.Name "try"
+
+_Data_tryWithHandler = Core.Name "tryWithHandler"
+
+_Data_function = Core.Name "function"
+
+_Data_contextFunction = Core.Name "contextFunction"
+
+_Data_polyFunction = Core.Name "polyFunction"
+
+_Data_partialFunction = Core.Name "partialFunction"
+
+_Data_while = Core.Name "while"
+
+_Data_do = Core.Name "do"
+
+_Data_for = Core.Name "for"
+
+_Data_forYield = Core.Name "forYield"
+
+_Data_new = Core.Name "new"
+
+_Data_newAnonymous = Core.Name "newAnonymous"
+
+_Data_placeholder = Core.Name "placeholder"
+
+_Data_eta = Core.Name "eta"
+
+_Data_repeated = Core.Name "repeated"
+
+_Data_param = Core.Name "param"
+
+data RefData =
+  RefDataThis ThisData |
+  RefDataSuper SuperData |
+  RefDataName NameData |
+  RefDataAnonymous AnonymousData |
+  RefDataSelect SelectData |
+  RefDataApplyUnary ApplyUnaryData
+  deriving (Eq, Ord, Read, Show)
+
+_RefData = Core.Name "hydra.scala.syntax.RefData"
+
+_RefData_this = Core.Name "this"
+
+_RefData_super = Core.Name "super"
+
+_RefData_name = Core.Name "name"
+
+_RefData_anonymous = Core.Name "anonymous"
+
+_RefData_select = Core.Name "select"
+
+_RefData_applyUnary = Core.Name "applyUnary"
+
+newtype ThisData =
+  ThisData {
+    unThisData :: ()}
+  deriving (Eq, Ord, Read, Show)
+
+_ThisData = Core.Name "hydra.scala.syntax.ThisData"
+
+data SuperData =
+  SuperData {
+    superDataThisp :: Name,
+    superDataSuperp :: Name}
+  deriving (Eq, Ord, Read, Show)
+
+_SuperData = Core.Name "hydra.scala.syntax.SuperData"
+
+_SuperData_thisp = Core.Name "thisp"
+
+_SuperData_superp = Core.Name "superp"
+
+data NameData =
+  NameData {
+    nameDataValue :: PredefString}
+  deriving (Eq, Ord, Read, Show)
+
+_NameData = Core.Name "hydra.scala.syntax.NameData"
+
+_NameData_value = Core.Name "value"
+
+newtype AnonymousData =
+  AnonymousData {
+    unAnonymousData :: ()}
+  deriving (Eq, Ord, Read, Show)
+
+_AnonymousData = Core.Name "hydra.scala.syntax.AnonymousData"
+
+data SelectData =
+  SelectData {
+    selectDataQual :: Data,
+    selectDataName :: NameData}
+  deriving (Eq, Ord, Read, Show)
+
+_SelectData = Core.Name "hydra.scala.syntax.SelectData"
+
+_SelectData_qual = Core.Name "qual"
+
+_SelectData_name = Core.Name "name"
+
+data InterpolateData =
+  InterpolateData {
+    interpolateDataPrefix :: NameData,
+    interpolateDataParts :: [Lit],
+    interpolateDataArgs :: [Data]}
+  deriving (Eq, Ord, Read, Show)
+
+_InterpolateData = Core.Name "hydra.scala.syntax.InterpolateData"
+
+_InterpolateData_prefix = Core.Name "prefix"
+
+_InterpolateData_parts = Core.Name "parts"
+
+_InterpolateData_args = Core.Name "args"
+
+data ApplyData =
+  ApplyData {
+    applyDataFun :: Data,
+    applyDataArgs :: [Data]}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplyData = Core.Name "hydra.scala.syntax.ApplyData"
+
+_ApplyData_fun = Core.Name "fun"
+
+_ApplyData_args = Core.Name "args"
+
+data ApplyUsingData =
+  ApplyUsingData {
+    applyUsingDataFun :: Data,
+    applyUsingDataTargs :: [Data]}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplyUsingData = Core.Name "hydra.scala.syntax.ApplyUsingData"
+
+_ApplyUsingData_fun = Core.Name "fun"
+
+_ApplyUsingData_targs = Core.Name "targs"
+
+data ApplyTypeData =
+  ApplyTypeData {
+    applyTypeDataLhs :: Data,
+    applyTypeDataOp :: NameData,
+    applyTypeDataTargs :: [Type],
+    applyTypeDataArgs :: [Data]}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplyTypeData = Core.Name "hydra.scala.syntax.ApplyTypeData"
+
+_ApplyTypeData_lhs = Core.Name "lhs"
+
+_ApplyTypeData_op = Core.Name "op"
+
+_ApplyTypeData_targs = Core.Name "targs"
+
+_ApplyTypeData_args = Core.Name "args"
+
+data ApplyInfixData =
+  ApplyInfixData {
+    applyInfixDataLhs :: Data,
+    applyInfixDataOp :: NameData,
+    applyInfixDataTargs :: [Type],
+    applyInfixDataArgs :: [Data]}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplyInfixData = Core.Name "hydra.scala.syntax.ApplyInfixData"
+
+_ApplyInfixData_lhs = Core.Name "lhs"
+
+_ApplyInfixData_op = Core.Name "op"
+
+_ApplyInfixData_targs = Core.Name "targs"
+
+_ApplyInfixData_args = Core.Name "args"
+
+data ApplyUnaryData =
+  ApplyUnaryData {
+    applyUnaryDataOp :: NameData,
+    applyUnaryDataArg :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplyUnaryData = Core.Name "hydra.scala.syntax.ApplyUnaryData"
+
+_ApplyUnaryData_op = Core.Name "op"
+
+_ApplyUnaryData_arg = Core.Name "arg"
+
+data AssignData =
+  AssignData {
+    assignDataLhs :: Data,
+    assignDataRhs :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_AssignData = Core.Name "hydra.scala.syntax.AssignData"
+
+_AssignData_lhs = Core.Name "lhs"
+
+_AssignData_rhs = Core.Name "rhs"
+
+data ReturnData =
+  ReturnData {
+    returnDataExpr :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_ReturnData = Core.Name "hydra.scala.syntax.ReturnData"
+
+_ReturnData_expr = Core.Name "expr"
+
+data ThrowData =
+  ThrowData {
+    throwDataExpr :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_ThrowData = Core.Name "hydra.scala.syntax.ThrowData"
+
+_ThrowData_expr = Core.Name "expr"
+
+data AscribeData =
+  AscribeData {
+    ascribeDataExpr :: Data,
+    ascribeDataTpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_AscribeData = Core.Name "hydra.scala.syntax.AscribeData"
+
+_AscribeData_expr = Core.Name "expr"
+
+_AscribeData_tpe = Core.Name "tpe"
+
+data AnnotateData =
+  AnnotateData {
+    annotateDataExpr :: Data,
+    annotateDataAnnots :: [AnnotMod]}
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotateData = Core.Name "hydra.scala.syntax.AnnotateData"
+
+_AnnotateData_expr = Core.Name "expr"
+
+_AnnotateData_annots = Core.Name "annots"
+
+data TupleData =
+  TupleData {
+    tupleDataArgs :: [Data]}
+  deriving (Eq, Ord, Read, Show)
+
+_TupleData = Core.Name "hydra.scala.syntax.TupleData"
+
+_TupleData_args = Core.Name "args"
+
+data BlockData =
+  BlockData {
+    blockDataStats :: [Stat]}
+  deriving (Eq, Ord, Read, Show)
+
+_BlockData = Core.Name "hydra.scala.syntax.BlockData"
+
+_BlockData_stats = Core.Name "stats"
+
+data EndMarkerData =
+  EndMarkerData {
+    endMarkerDataName :: NameData}
+  deriving (Eq, Ord, Read, Show)
+
+_EndMarkerData = Core.Name "hydra.scala.syntax.EndMarkerData"
+
+_EndMarkerData_name = Core.Name "name"
+
+data IfData =
+  IfData {
+    ifDataCond :: Data,
+    ifDataThenp :: Data,
+    ifDataElsep :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_IfData = Core.Name "hydra.scala.syntax.IfData"
+
+_IfData_cond = Core.Name "cond"
+
+_IfData_thenp = Core.Name "thenp"
+
+_IfData_elsep = Core.Name "elsep"
+
+data MatchData =
+  MatchData {
+    matchDataExpr :: Data,
+    matchDataCases :: [Case]}
+  deriving (Eq, Ord, Read, Show)
+
+_MatchData = Core.Name "hydra.scala.syntax.MatchData"
+
+_MatchData_expr = Core.Name "expr"
+
+_MatchData_cases = Core.Name "cases"
+
+data TryData =
+  TryData {
+    tryDataExpr :: Data,
+    tryDataCatchp :: [Case],
+    tryDataFinallyp :: (Maybe Data)}
+  deriving (Eq, Ord, Read, Show)
+
+_TryData = Core.Name "hydra.scala.syntax.TryData"
+
+_TryData_expr = Core.Name "expr"
+
+_TryData_catchp = Core.Name "catchp"
+
+_TryData_finallyp = Core.Name "finallyp"
+
+data TryWithHandlerData =
+  TryWithHandlerData {
+    tryWithHandlerDataExpr :: Data,
+    tryWithHandlerDataCatchp :: Data,
+    tryWithHandlerDataFinallyp :: (Maybe Data)}
+  deriving (Eq, Ord, Read, Show)
+
+_TryWithHandlerData = Core.Name "hydra.scala.syntax.TryWithHandlerData"
+
+_TryWithHandlerData_expr = Core.Name "expr"
+
+_TryWithHandlerData_catchp = Core.Name "catchp"
+
+_TryWithHandlerData_finallyp = Core.Name "finallyp"
+
+data ContextFunctionData =
+  ContextFunctionData {
+    contextFunctionDataParams :: [ParamData],
+    contextFunctionDataBody :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_ContextFunctionData = Core.Name "hydra.scala.syntax.ContextFunctionData"
+
+_ContextFunctionData_params = Core.Name "params"
+
+_ContextFunctionData_body = Core.Name "body"
+
+data FunctionData =
+  FunctionData {
+    functionDataParams :: [ParamData],
+    functionDataBody :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_FunctionData = Core.Name "hydra.scala.syntax.FunctionData"
+
+_FunctionData_params = Core.Name "params"
+
+_FunctionData_body = Core.Name "body"
+
+data PolyFunctionData =
+  PolyFunctionData {
+    polyFunctionDataTparams :: [ParamType],
+    polyFunctionDataBody :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_PolyFunctionData = Core.Name "hydra.scala.syntax.PolyFunctionData"
+
+_PolyFunctionData_tparams = Core.Name "tparams"
+
+_PolyFunctionData_body = Core.Name "body"
+
+data PartialFunctionData =
+  PartialFunctionData {
+    partialFunctionDataCases :: [Case]}
+  deriving (Eq, Ord, Read, Show)
+
+_PartialFunctionData = Core.Name "hydra.scala.syntax.PartialFunctionData"
+
+_PartialFunctionData_cases = Core.Name "cases"
+
+data WhileData =
+  WhileData {
+    whileDataExpr :: Data,
+    whileDataBody :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_WhileData = Core.Name "hydra.scala.syntax.WhileData"
+
+_WhileData_expr = Core.Name "expr"
+
+_WhileData_body = Core.Name "body"
+
+data DoData =
+  DoData {
+    doDataBody :: Data,
+    doDataExpr :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_DoData = Core.Name "hydra.scala.syntax.DoData"
+
+_DoData_body = Core.Name "body"
+
+_DoData_expr = Core.Name "expr"
+
+data ForData =
+  ForData {
+    forDataEnums :: [Enumerator]}
+  deriving (Eq, Ord, Read, Show)
+
+_ForData = Core.Name "hydra.scala.syntax.ForData"
+
+_ForData_enums = Core.Name "enums"
+
+data ForYieldData =
+  ForYieldData {
+    forYieldDataEnums :: [Enumerator]}
+  deriving (Eq, Ord, Read, Show)
+
+_ForYieldData = Core.Name "hydra.scala.syntax.ForYieldData"
+
+_ForYieldData_enums = Core.Name "enums"
+
+data NewData =
+  NewData {
+    newDataInit :: Init}
+  deriving (Eq, Ord, Read, Show)
+
+_NewData = Core.Name "hydra.scala.syntax.NewData"
+
+_NewData_init = Core.Name "init"
+
+data NewAnonymousData =
+  NewAnonymousData {
+    newAnonymousDataTempl :: Template}
+  deriving (Eq, Ord, Read, Show)
+
+_NewAnonymousData = Core.Name "hydra.scala.syntax.NewAnonymousData"
+
+_NewAnonymousData_templ = Core.Name "templ"
+
+data EtaData =
+  EtaData {
+    etaDataExpr :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_EtaData = Core.Name "hydra.scala.syntax.EtaData"
+
+_EtaData_expr = Core.Name "expr"
+
+data RepeatedData =
+  RepeatedData {
+    repeatedDataExpr :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_RepeatedData = Core.Name "hydra.scala.syntax.RepeatedData"
+
+_RepeatedData_expr = Core.Name "expr"
+
+data ParamData =
+  ParamData {
+    paramDataMods :: [Mod],
+    paramDataName :: Name,
+    paramDataDecltpe :: (Maybe Type),
+    paramDataDefault :: (Maybe Data)}
+  deriving (Eq, Ord, Read, Show)
+
+_ParamData = Core.Name "hydra.scala.syntax.ParamData"
+
+_ParamData_mods = Core.Name "mods"
+
+_ParamData_name = Core.Name "name"
+
+_ParamData_decltpe = Core.Name "decltpe"
+
+_ParamData_default = Core.Name "default"
+
+data Type =
+  TypeRef RefType |
+  TypeAnonymousName AnonymousNameType |
+  TypeApply ApplyType |
+  TypeApplyInfix ApplyInfixType |
+  TypeFunction FunctionType |
+  TypeContextFunction ContextFunctionType |
+  TypePolyFunction PolyFunctionType |
+  TypeImplicitFunction ImplicitFunctionType |
+  TypeTuple TupleType |
+  TypeWith WithType |
+  TypeAnd AndType |
+  TypeOr OrType |
+  TypeRefine RefineType |
+  TypeExistential ExistentialType |
+  TypeAnnotate AnnotateType |
+  TypeLambda LambdaType |
+  TypeMethod MethodType |
+  TypePlaceholder PlaceholderType |
+  TypeByName ByNameType |
+  TypeRepeated RepeatedType |
+  TypeVar VarType |
+  TypeTypedParam TypedParamType |
+  TypeMatch MatchType
+  deriving (Eq, Ord, Read, Show)
+
+_Type = Core.Name "hydra.scala.syntax.Type"
+
+_Type_ref = Core.Name "ref"
+
+_Type_anonymousName = Core.Name "anonymousName"
+
+_Type_apply = Core.Name "apply"
+
+_Type_applyInfix = Core.Name "applyInfix"
+
+_Type_function = Core.Name "function"
+
+_Type_contextFunction = Core.Name "contextFunction"
+
+_Type_polyFunction = Core.Name "polyFunction"
+
+_Type_implicitFunction = Core.Name "implicitFunction"
+
+_Type_tuple = Core.Name "tuple"
+
+_Type_with = Core.Name "with"
+
+_Type_and = Core.Name "and"
+
+_Type_or = Core.Name "or"
+
+_Type_refine = Core.Name "refine"
+
+_Type_existential = Core.Name "existential"
+
+_Type_annotate = Core.Name "annotate"
+
+_Type_lambda = Core.Name "lambda"
+
+_Type_method = Core.Name "method"
+
+_Type_placeholder = Core.Name "placeholder"
+
+_Type_byName = Core.Name "byName"
+
+_Type_repeated = Core.Name "repeated"
+
+_Type_var = Core.Name "var"
+
+_Type_typedParam = Core.Name "typedParam"
+
+_Type_match = Core.Name "match"
+
+data RefType =
+  RefTypeName NameType |
+  RefTypeSelect SelectType |
+  RefTypeProject ProjectType |
+  RefTypeSingleton SingletonType
+  deriving (Eq, Ord, Read, Show)
+
+_RefType = Core.Name "hydra.scala.syntax.RefType"
+
+_RefType_name = Core.Name "name"
+
+_RefType_select = Core.Name "select"
+
+_RefType_project = Core.Name "project"
+
+_RefType_singleton = Core.Name "singleton"
+
+data NameType =
+  NameType {
+    nameTypeValue :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_NameType = Core.Name "hydra.scala.syntax.NameType"
+
+_NameType_value = Core.Name "value"
+
+newtype AnonymousNameType =
+  AnonymousNameType {
+    unAnonymousNameType :: ()}
+  deriving (Eq, Ord, Read, Show)
+
+_AnonymousNameType = Core.Name "hydra.scala.syntax.AnonymousNameType"
+
+data SelectType =
+  SelectType {
+    selectTypeQual :: RefData,
+    selectTypeName :: NameType}
+  deriving (Eq, Ord, Read, Show)
+
+_SelectType = Core.Name "hydra.scala.syntax.SelectType"
+
+_SelectType_qual = Core.Name "qual"
+
+_SelectType_name = Core.Name "name"
+
+data ProjectType =
+  ProjectType {
+    projectTypeQual :: Type,
+    projectTypeName :: NameType}
+  deriving (Eq, Ord, Read, Show)
+
+_ProjectType = Core.Name "hydra.scala.syntax.ProjectType"
+
+_ProjectType_qual = Core.Name "qual"
+
+_ProjectType_name = Core.Name "name"
+
+data SingletonType =
+  SingletonType {
+    singletonTypeRef :: RefData}
+  deriving (Eq, Ord, Read, Show)
+
+_SingletonType = Core.Name "hydra.scala.syntax.SingletonType"
+
+_SingletonType_ref = Core.Name "ref"
+
+data ApplyType =
+  ApplyType {
+    applyTypeTpe :: Type,
+    applyTypeArgs :: [Type]}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplyType = Core.Name "hydra.scala.syntax.ApplyType"
+
+_ApplyType_tpe = Core.Name "tpe"
+
+_ApplyType_args = Core.Name "args"
+
+data ApplyInfixType =
+  ApplyInfixType {
+    applyInfixTypeLhs :: Type,
+    applyInfixTypeOp :: NameType,
+    applyInfixTypeRhs :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplyInfixType = Core.Name "hydra.scala.syntax.ApplyInfixType"
+
+_ApplyInfixType_lhs = Core.Name "lhs"
+
+_ApplyInfixType_op = Core.Name "op"
+
+_ApplyInfixType_rhs = Core.Name "rhs"
+
+data FunctionType =
+  FunctionType {
+    functionTypeParams :: [Type],
+    functionTypeRes :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_FunctionType = Core.Name "hydra.scala.syntax.FunctionType"
+
+_FunctionType_params = Core.Name "params"
+
+_FunctionType_res = Core.Name "res"
+
+data PolyFunctionType =
+  PolyFunctionType {
+    polyFunctionTypeTparams :: [ParamType],
+    polyFunctionTypeTpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_PolyFunctionType = Core.Name "hydra.scala.syntax.PolyFunctionType"
+
+_PolyFunctionType_tparams = Core.Name "tparams"
+
+_PolyFunctionType_tpe = Core.Name "tpe"
+
+data ContextFunctionType =
+  ContextFunctionType {
+    contextFunctionTypeParams :: [Type],
+    contextFunctionTypeRes :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ContextFunctionType = Core.Name "hydra.scala.syntax.ContextFunctionType"
+
+_ContextFunctionType_params = Core.Name "params"
+
+_ContextFunctionType_res = Core.Name "res"
+
+data ImplicitFunctionType =
+  ImplicitFunctionType {
+    implicitFunctionTypeParams :: [Type],
+    implicitFunctionTypeRes :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ImplicitFunctionType = Core.Name "hydra.scala.syntax.ImplicitFunctionType"
+
+_ImplicitFunctionType_params = Core.Name "params"
+
+_ImplicitFunctionType_res = Core.Name "res"
+
+data TupleType =
+  TupleType {
+    tupleTypeArgs :: [Type]}
+  deriving (Eq, Ord, Read, Show)
+
+_TupleType = Core.Name "hydra.scala.syntax.TupleType"
+
+_TupleType_args = Core.Name "args"
+
+data WithType =
+  WithType {
+    withTypeLhs :: Type,
+    withTypeRhs :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_WithType = Core.Name "hydra.scala.syntax.WithType"
+
+_WithType_lhs = Core.Name "lhs"
+
+_WithType_rhs = Core.Name "rhs"
+
+data AndType =
+  AndType {
+    andTypeLhs :: Type,
+    andTypeRhs :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_AndType = Core.Name "hydra.scala.syntax.AndType"
+
+_AndType_lhs = Core.Name "lhs"
+
+_AndType_rhs = Core.Name "rhs"
+
+data OrType =
+  OrType {
+    orTypeLhs :: Type,
+    orTypeRhs :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_OrType = Core.Name "hydra.scala.syntax.OrType"
+
+_OrType_lhs = Core.Name "lhs"
+
+_OrType_rhs = Core.Name "rhs"
+
+data RefineType =
+  RefineType {
+    refineTypeTpe :: (Maybe Type),
+    refineTypeStats :: [Stat]}
+  deriving (Eq, Ord, Read, Show)
+
+_RefineType = Core.Name "hydra.scala.syntax.RefineType"
+
+_RefineType_tpe = Core.Name "tpe"
+
+_RefineType_stats = Core.Name "stats"
+
+data ExistentialType =
+  ExistentialType {
+    existentialTypeTpe :: Type,
+    existentialTypeStats :: [Stat]}
+  deriving (Eq, Ord, Read, Show)
+
+_ExistentialType = Core.Name "hydra.scala.syntax.ExistentialType"
+
+_ExistentialType_tpe = Core.Name "tpe"
+
+_ExistentialType_stats = Core.Name "stats"
+
+data AnnotateType =
+  AnnotateType {
+    annotateTypeTpe :: Type,
+    annotateTypeAnnots :: [AnnotMod]}
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotateType = Core.Name "hydra.scala.syntax.AnnotateType"
+
+_AnnotateType_tpe = Core.Name "tpe"
+
+_AnnotateType_annots = Core.Name "annots"
+
+data LambdaType =
+  LambdaType {
+    lambdaTypeTparams :: [ParamType],
+    lambdaTypeTpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_LambdaType = Core.Name "hydra.scala.syntax.LambdaType"
+
+_LambdaType_tparams = Core.Name "tparams"
+
+_LambdaType_tpe = Core.Name "tpe"
+
+data MethodType =
+  MethodType {
+    methodTypeParamss :: [[ParamData]],
+    methodTypeTpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_MethodType = Core.Name "hydra.scala.syntax.MethodType"
+
+_MethodType_paramss = Core.Name "paramss"
+
+_MethodType_tpe = Core.Name "tpe"
+
+data PlaceholderType =
+  PlaceholderType {
+    placeholderTypeBounds :: TypeBounds}
+  deriving (Eq, Ord, Read, Show)
+
+_PlaceholderType = Core.Name "hydra.scala.syntax.PlaceholderType"
+
+_PlaceholderType_bounds = Core.Name "bounds"
+
+data TypeBounds =
+  TypeBounds {
+    typeBoundsLo :: (Maybe Type),
+    typeBoundsHi :: (Maybe Type)}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeBounds = Core.Name "hydra.scala.syntax.TypeBounds"
+
+_TypeBounds_lo = Core.Name "lo"
+
+_TypeBounds_hi = Core.Name "hi"
+
+data ByNameType =
+  ByNameType {
+    byNameTypeTpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ByNameType = Core.Name "hydra.scala.syntax.ByNameType"
+
+_ByNameType_tpe = Core.Name "tpe"
+
+data RepeatedType =
+  RepeatedType {
+    repeatedTypeTpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_RepeatedType = Core.Name "hydra.scala.syntax.RepeatedType"
+
+_RepeatedType_tpe = Core.Name "tpe"
+
+data VarType =
+  VarType {
+    varTypeName :: NameType}
+  deriving (Eq, Ord, Read, Show)
+
+_VarType = Core.Name "hydra.scala.syntax.VarType"
+
+_VarType_name = Core.Name "name"
+
+data TypedParamType =
+  TypedParamType {
+    typedParamTypeName :: Name,
+    typedParamTypeTyp :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_TypedParamType = Core.Name "hydra.scala.syntax.TypedParamType"
+
+_TypedParamType_name = Core.Name "name"
+
+_TypedParamType_typ = Core.Name "typ"
+
+data ParamType =
+  ParamType {
+    paramTypeMods :: [Mod],
+    paramTypeName :: Name,
+    paramTypeTparams :: [ParamType],
+    paramTypeTbounds :: [TypeBounds],
+    paramTypeVbounds :: [Type],
+    paramTypeCbounds :: [Type]}
+  deriving (Eq, Ord, Read, Show)
+
+_ParamType = Core.Name "hydra.scala.syntax.ParamType"
+
+_ParamType_mods = Core.Name "mods"
+
+_ParamType_name = Core.Name "name"
+
+_ParamType_tparams = Core.Name "tparams"
+
+_ParamType_tbounds = Core.Name "tbounds"
+
+_ParamType_vbounds = Core.Name "vbounds"
+
+_ParamType_cbounds = Core.Name "cbounds"
+
+data MatchType =
+  MatchType {
+    matchTypeTpe :: Type,
+    matchTypeCases :: [TypeCase]}
+  deriving (Eq, Ord, Read, Show)
+
+_MatchType = Core.Name "hydra.scala.syntax.MatchType"
+
+_MatchType_tpe = Core.Name "tpe"
+
+_MatchType_cases = Core.Name "cases"
+
+data Pat =
+  PatVar VarPat |
+  PatWildcard |
+  PatSeqWildcard |
+  PatBind BindPat |
+  PatAlternative AlternativePat |
+  PatTuple TuplePat |
+  PatRepeated RepeatedPat |
+  PatExtract ExtractPat |
+  PatExtractInfix ExtractInfixPat |
+  PatInterpolate InterpolatePat |
+  PatTyped TypedPat |
+  PatGiven GivenPat
+  deriving (Eq, Ord, Read, Show)
+
+_Pat = Core.Name "hydra.scala.syntax.Pat"
+
+_Pat_var = Core.Name "var"
+
+_Pat_wildcard = Core.Name "wildcard"
+
+_Pat_seqWildcard = Core.Name "seqWildcard"
+
+_Pat_bind = Core.Name "bind"
+
+_Pat_alternative = Core.Name "alternative"
+
+_Pat_tuple = Core.Name "tuple"
+
+_Pat_repeated = Core.Name "repeated"
+
+_Pat_extract = Core.Name "extract"
+
+_Pat_extractInfix = Core.Name "extractInfix"
+
+_Pat_interpolate = Core.Name "interpolate"
+
+_Pat_typed = Core.Name "typed"
+
+_Pat_given = Core.Name "given"
+
+data VarPat =
+  VarPat {
+    varPatName :: NameData}
+  deriving (Eq, Ord, Read, Show)
+
+_VarPat = Core.Name "hydra.scala.syntax.VarPat"
+
+_VarPat_name = Core.Name "name"
+
+data BindPat =
+  BindPat {
+    bindPatLhs :: Pat,
+    bindPatRhs :: Pat}
+  deriving (Eq, Ord, Read, Show)
+
+_BindPat = Core.Name "hydra.scala.syntax.BindPat"
+
+_BindPat_lhs = Core.Name "lhs"
+
+_BindPat_rhs = Core.Name "rhs"
+
+data AlternativePat =
+  AlternativePat {
+    alternativePatLhs :: Pat,
+    alternativePatRhs :: Pat}
+  deriving (Eq, Ord, Read, Show)
+
+_AlternativePat = Core.Name "hydra.scala.syntax.AlternativePat"
+
+_AlternativePat_lhs = Core.Name "lhs"
+
+_AlternativePat_rhs = Core.Name "rhs"
+
+data TuplePat =
+  TuplePat {
+    tuplePatArgs :: [Pat]}
+  deriving (Eq, Ord, Read, Show)
+
+_TuplePat = Core.Name "hydra.scala.syntax.TuplePat"
+
+_TuplePat_args = Core.Name "args"
+
+data RepeatedPat =
+  RepeatedPat {
+    repeatedPatName :: NameData}
+  deriving (Eq, Ord, Read, Show)
+
+_RepeatedPat = Core.Name "hydra.scala.syntax.RepeatedPat"
+
+_RepeatedPat_name = Core.Name "name"
+
+data ExtractPat =
+  ExtractPat {
+    extractPatFun :: Data,
+    extractPatArgs :: [Pat]}
+  deriving (Eq, Ord, Read, Show)
+
+_ExtractPat = Core.Name "hydra.scala.syntax.ExtractPat"
+
+_ExtractPat_fun = Core.Name "fun"
+
+_ExtractPat_args = Core.Name "args"
+
+data ExtractInfixPat =
+  ExtractInfixPat {
+    extractInfixPatLhs :: Pat,
+    extractInfixPatOp :: NameData,
+    extractInfixPatRhs :: [Pat]}
+  deriving (Eq, Ord, Read, Show)
+
+_ExtractInfixPat = Core.Name "hydra.scala.syntax.ExtractInfixPat"
+
+_ExtractInfixPat_lhs = Core.Name "lhs"
+
+_ExtractInfixPat_op = Core.Name "op"
+
+_ExtractInfixPat_rhs = Core.Name "rhs"
+
+data InterpolatePat =
+  InterpolatePat {
+    interpolatePatPrefix :: NameData,
+    interpolatePatParts :: [Lit]}
+  deriving (Eq, Ord, Read, Show)
+
+_InterpolatePat = Core.Name "hydra.scala.syntax.InterpolatePat"
+
+_InterpolatePat_prefix = Core.Name "prefix"
+
+_InterpolatePat_parts = Core.Name "parts"
+
+data TypedPat =
+  TypedPat {
+    typedPatLhs :: Pat,
+    typedPatRhs :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_TypedPat = Core.Name "hydra.scala.syntax.TypedPat"
+
+_TypedPat_lhs = Core.Name "lhs"
+
+_TypedPat_rhs = Core.Name "rhs"
+
+data GivenPat =
+  GivenPat {
+    givenPatTpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_GivenPat = Core.Name "hydra.scala.syntax.GivenPat"
+
+_GivenPat_tpe = Core.Name "tpe"
+
+data Member =
+  MemberTerm DataMember |
+  MemberType TypeMember |
+  MemberTermParam ParamData |
+  MemberTypeParam ParamType |
+  MemberSelf Self
+  deriving (Eq, Ord, Read, Show)
+
+_Member = Core.Name "hydra.scala.syntax.Member"
+
+_Member_term = Core.Name "term"
+
+_Member_type = Core.Name "type"
+
+_Member_termParam = Core.Name "termParam"
+
+_Member_typeParam = Core.Name "typeParam"
+
+_Member_self = Core.Name "self"
+
+data DataMember =
+  DataMemberPkg Pkg |
+  DataMemberObject ObjectPkg
+  deriving (Eq, Ord, Read, Show)
+
+_DataMember = Core.Name "hydra.scala.syntax.DataMember"
+
+_DataMember_pkg = Core.Name "pkg"
+
+_DataMember_object = Core.Name "object"
+
+data TypeMember =
+  TypeMember {
+    typeMemberName :: NameType}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeMember = Core.Name "hydra.scala.syntax.TypeMember"
+
+_TypeMember_name = Core.Name "name"
+
+data Decl =
+  DeclVal ValDecl |
+  DeclVar VarDecl |
+  DeclDef DefDecl |
+  DeclType TypeDecl |
+  DeclGiven GivenDecl
+  deriving (Eq, Ord, Read, Show)
+
+_Decl = Core.Name "hydra.scala.syntax.Decl"
+
+_Decl_val = Core.Name "val"
+
+_Decl_var = Core.Name "var"
+
+_Decl_def = Core.Name "def"
+
+_Decl_type = Core.Name "type"
+
+_Decl_given = Core.Name "given"
+
+data ValDecl =
+  ValDecl {
+    valDeclMods :: [Mod],
+    valDeclPats :: [Pat],
+    valDeclDecltpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ValDecl = Core.Name "hydra.scala.syntax.ValDecl"
+
+_ValDecl_mods = Core.Name "mods"
+
+_ValDecl_pats = Core.Name "pats"
+
+_ValDecl_decltpe = Core.Name "decltpe"
+
+data VarDecl =
+  VarDecl {
+    varDeclMods :: [Mod],
+    varDeclPats :: [Pat],
+    varDeclDecltpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_VarDecl = Core.Name "hydra.scala.syntax.VarDecl"
+
+_VarDecl_mods = Core.Name "mods"
+
+_VarDecl_pats = Core.Name "pats"
+
+_VarDecl_decltpe = Core.Name "decltpe"
+
+data DefDecl =
+  DefDecl {
+    defDeclMods :: [Mod],
+    defDeclName :: NameData,
+    defDeclTparams :: [ParamType],
+    defDeclParamss :: [[ParamData]],
+    defDeclDecltpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_DefDecl = Core.Name "hydra.scala.syntax.DefDecl"
+
+_DefDecl_mods = Core.Name "mods"
+
+_DefDecl_name = Core.Name "name"
+
+_DefDecl_tparams = Core.Name "tparams"
+
+_DefDecl_paramss = Core.Name "paramss"
+
+_DefDecl_decltpe = Core.Name "decltpe"
+
+data TypeDecl =
+  TypeDecl {
+    typeDeclMods :: [Mod],
+    typeDeclName :: NameType,
+    typeDeclTparams :: [ParamType],
+    typeDeclBounds :: TypeBounds}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeDecl = Core.Name "hydra.scala.syntax.TypeDecl"
+
+_TypeDecl_mods = Core.Name "mods"
+
+_TypeDecl_name = Core.Name "name"
+
+_TypeDecl_tparams = Core.Name "tparams"
+
+_TypeDecl_bounds = Core.Name "bounds"
+
+data GivenDecl =
+  GivenDecl {
+    givenDeclMods :: [Mod],
+    givenDeclName :: NameData,
+    givenDeclTparams :: [ParamType],
+    givenDeclSparams :: [[ParamData]],
+    givenDeclDecltpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_GivenDecl = Core.Name "hydra.scala.syntax.GivenDecl"
+
+_GivenDecl_mods = Core.Name "mods"
+
+_GivenDecl_name = Core.Name "name"
+
+_GivenDecl_tparams = Core.Name "tparams"
+
+_GivenDecl_sparams = Core.Name "sparams"
+
+_GivenDecl_decltpe = Core.Name "decltpe"
+
+data Defn =
+  DefnVal ValDefn |
+  DefnVar VarDefn |
+  DefnGiven GivenDefn |
+  DefnEnum EnumDefn |
+  DefnEnumCase EnumCaseDefn |
+  DefnRepeatedEnumCase RepeatedEnumCaseDefn |
+  DefnGivenAlias GivenAliasDefn |
+  DefnExtensionGroup ExtensionGroupDefn |
+  DefnDef DefDefn |
+  DefnType TypeDefn |
+  DefnClass ClassDefn |
+  DefnTrait TraitDefn |
+  DefnObject ObjectDefn
+  deriving (Eq, Ord, Read, Show)
+
+_Defn = Core.Name "hydra.scala.syntax.Defn"
+
+_Defn_val = Core.Name "val"
+
+_Defn_var = Core.Name "var"
+
+_Defn_given = Core.Name "given"
+
+_Defn_enum = Core.Name "enum"
+
+_Defn_enumCase = Core.Name "enumCase"
+
+_Defn_repeatedEnumCase = Core.Name "repeatedEnumCase"
+
+_Defn_givenAlias = Core.Name "givenAlias"
+
+_Defn_extensionGroup = Core.Name "extensionGroup"
+
+_Defn_def = Core.Name "def"
+
+_Defn_type = Core.Name "type"
+
+_Defn_class = Core.Name "class"
+
+_Defn_trait = Core.Name "trait"
+
+_Defn_object = Core.Name "object"
+
+data ValDefn =
+  ValDefn {
+    valDefnMods :: [Mod],
+    valDefnPats :: [Pat],
+    valDefnDecltpe :: (Maybe Type),
+    valDefnRhs :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_ValDefn = Core.Name "hydra.scala.syntax.ValDefn"
+
+_ValDefn_mods = Core.Name "mods"
+
+_ValDefn_pats = Core.Name "pats"
+
+_ValDefn_decltpe = Core.Name "decltpe"
+
+_ValDefn_rhs = Core.Name "rhs"
+
+data VarDefn =
+  VarDefn {
+    varDefnMods :: [Mod],
+    varDefnPats :: [Pat],
+    varDefnDecltpe :: Type,
+    varDefnRhs :: (Maybe Data)}
+  deriving (Eq, Ord, Read, Show)
+
+_VarDefn = Core.Name "hydra.scala.syntax.VarDefn"
+
+_VarDefn_mods = Core.Name "mods"
+
+_VarDefn_pats = Core.Name "pats"
+
+_VarDefn_decltpe = Core.Name "decltpe"
+
+_VarDefn_rhs = Core.Name "rhs"
+
+data GivenDefn =
+  GivenDefn {
+    givenDefnMods :: [Mod],
+    givenDefnName :: Name,
+    givenDefnTparams :: [[ParamType]],
+    givenDefnSparams :: [[ParamData]],
+    givenDefnTempl :: Template}
+  deriving (Eq, Ord, Read, Show)
+
+_GivenDefn = Core.Name "hydra.scala.syntax.GivenDefn"
+
+_GivenDefn_mods = Core.Name "mods"
+
+_GivenDefn_name = Core.Name "name"
+
+_GivenDefn_tparams = Core.Name "tparams"
+
+_GivenDefn_sparams = Core.Name "sparams"
+
+_GivenDefn_templ = Core.Name "templ"
+
+data EnumDefn =
+  EnumDefn {
+    enumDefnMods :: [Mod],
+    enumDefnName :: NameType,
+    enumDefnTparams :: [ParamType],
+    enumDefnCtor :: PrimaryCtor,
+    enumDefnTemplate :: Template}
+  deriving (Eq, Ord, Read, Show)
+
+_EnumDefn = Core.Name "hydra.scala.syntax.EnumDefn"
+
+_EnumDefn_mods = Core.Name "mods"
+
+_EnumDefn_name = Core.Name "name"
+
+_EnumDefn_tparams = Core.Name "tparams"
+
+_EnumDefn_ctor = Core.Name "ctor"
+
+_EnumDefn_template = Core.Name "template"
+
+data EnumCaseDefn =
+  EnumCaseDefn {
+    enumCaseDefnMods :: [Mod],
+    enumCaseDefnName :: NameData,
+    enumCaseDefnTparams :: [ParamType],
+    enumCaseDefnCtor :: PrimaryCtor,
+    enumCaseDefnInits :: [Init]}
+  deriving (Eq, Ord, Read, Show)
+
+_EnumCaseDefn = Core.Name "hydra.scala.syntax.EnumCaseDefn"
+
+_EnumCaseDefn_mods = Core.Name "mods"
+
+_EnumCaseDefn_name = Core.Name "name"
+
+_EnumCaseDefn_tparams = Core.Name "tparams"
+
+_EnumCaseDefn_ctor = Core.Name "ctor"
+
+_EnumCaseDefn_inits = Core.Name "inits"
+
+data RepeatedEnumCaseDefn =
+  RepeatedEnumCaseDefn {
+    repeatedEnumCaseDefnMods :: [Mod],
+    repeatedEnumCaseDefnCases :: [NameData]}
+  deriving (Eq, Ord, Read, Show)
+
+_RepeatedEnumCaseDefn = Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"
+
+_RepeatedEnumCaseDefn_mods = Core.Name "mods"
+
+_RepeatedEnumCaseDefn_cases = Core.Name "cases"
+
+data GivenAliasDefn =
+  GivenAliasDefn {
+    givenAliasDefnMods :: [Mod],
+    givenAliasDefnName :: Name,
+    givenAliasDefnTparams :: [[ParamType]],
+    givenAliasDefnSparams :: [[ParamData]],
+    givenAliasDefnDecltpe :: Type,
+    givenAliasDefnBody :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_GivenAliasDefn = Core.Name "hydra.scala.syntax.GivenAliasDefn"
+
+_GivenAliasDefn_mods = Core.Name "mods"
+
+_GivenAliasDefn_name = Core.Name "name"
+
+_GivenAliasDefn_tparams = Core.Name "tparams"
+
+_GivenAliasDefn_sparams = Core.Name "sparams"
+
+_GivenAliasDefn_decltpe = Core.Name "decltpe"
+
+_GivenAliasDefn_body = Core.Name "body"
+
+data ExtensionGroupDefn =
+  ExtensionGroupDefn {
+    extensionGroupDefnTparams :: [ParamType],
+    extensionGroupDefnParmss :: [[ParamData]],
+    extensionGroupDefnBody :: Stat}
+  deriving (Eq, Ord, Read, Show)
+
+_ExtensionGroupDefn = Core.Name "hydra.scala.syntax.ExtensionGroupDefn"
+
+_ExtensionGroupDefn_tparams = Core.Name "tparams"
+
+_ExtensionGroupDefn_parmss = Core.Name "parmss"
+
+_ExtensionGroupDefn_body = Core.Name "body"
+
+data DefDefn =
+  DefDefn {
+    defDefnMods :: [Mod],
+    defDefnName :: NameData,
+    defDefnTparams :: [ParamType],
+    defDefnParamss :: [[ParamData]],
+    defDefnDecltpe :: (Maybe Type),
+    defDefnBody :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_DefDefn = Core.Name "hydra.scala.syntax.DefDefn"
+
+_DefDefn_mods = Core.Name "mods"
+
+_DefDefn_name = Core.Name "name"
+
+_DefDefn_tparams = Core.Name "tparams"
+
+_DefDefn_paramss = Core.Name "paramss"
+
+_DefDefn_decltpe = Core.Name "decltpe"
+
+_DefDefn_body = Core.Name "body"
+
+data TypeDefn =
+  TypeDefn {
+    typeDefnMods :: [Mod],
+    typeDefnName :: NameType,
+    typeDefnTparams :: [ParamType],
+    typeDefnBody :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeDefn = Core.Name "hydra.scala.syntax.TypeDefn"
+
+_TypeDefn_mods = Core.Name "mods"
+
+_TypeDefn_name = Core.Name "name"
+
+_TypeDefn_tparams = Core.Name "tparams"
+
+_TypeDefn_body = Core.Name "body"
+
+data ClassDefn =
+  ClassDefn {
+    classDefnMods :: [Mod],
+    classDefnName :: NameType,
+    classDefnTparams :: [ParamType],
+    classDefnCtor :: PrimaryCtor,
+    classDefnTemplate :: Template}
+  deriving (Eq, Ord, Read, Show)
+
+_ClassDefn = Core.Name "hydra.scala.syntax.ClassDefn"
+
+_ClassDefn_mods = Core.Name "mods"
+
+_ClassDefn_name = Core.Name "name"
+
+_ClassDefn_tparams = Core.Name "tparams"
+
+_ClassDefn_ctor = Core.Name "ctor"
+
+_ClassDefn_template = Core.Name "template"
+
+data TraitDefn =
+  TraitDefn {
+    traitDefnMods :: [Mod],
+    traitDefnName :: NameType,
+    traitDefnTparams :: [ParamType],
+    traitDefnCtor :: PrimaryCtor,
+    traitDefnTemplate :: Template}
+  deriving (Eq, Ord, Read, Show)
+
+_TraitDefn = Core.Name "hydra.scala.syntax.TraitDefn"
+
+_TraitDefn_mods = Core.Name "mods"
+
+_TraitDefn_name = Core.Name "name"
+
+_TraitDefn_tparams = Core.Name "tparams"
+
+_TraitDefn_ctor = Core.Name "ctor"
+
+_TraitDefn_template = Core.Name "template"
+
+data ObjectDefn =
+  ObjectDefn {
+    objectDefnName :: NameData}
+  deriving (Eq, Ord, Read, Show)
+
+_ObjectDefn = Core.Name "hydra.scala.syntax.ObjectDefn"
+
+_ObjectDefn_name = Core.Name "name"
+
+data Pkg =
+  Pkg {
+    pkgName :: NameData,
+    pkgRef :: RefData,
+    pkgStats :: [Stat]}
+  deriving (Eq, Ord, Read, Show)
+
+_Pkg = Core.Name "hydra.scala.syntax.Pkg"
+
+_Pkg_name = Core.Name "name"
+
+_Pkg_ref = Core.Name "ref"
+
+_Pkg_stats = Core.Name "stats"
+
+data ObjectPkg =
+  ObjectPkg {
+    objectPkgMods :: [Mod],
+    objectPkgName :: NameData,
+    objectPkgTemplate :: Template}
+  deriving (Eq, Ord, Read, Show)
+
+_ObjectPkg = Core.Name "hydra.scala.syntax.ObjectPkg"
+
+_ObjectPkg_mods = Core.Name "mods"
+
+_ObjectPkg_name = Core.Name "name"
+
+_ObjectPkg_template = Core.Name "template"
+
+data Ctor =
+  CtorPrimary PrimaryCtor |
+  CtorSecondary SecondaryCtor
+  deriving (Eq, Ord, Read, Show)
+
+_Ctor = Core.Name "hydra.scala.syntax.Ctor"
+
+_Ctor_primary = Core.Name "primary"
+
+_Ctor_secondary = Core.Name "secondary"
+
+data PrimaryCtor =
+  PrimaryCtor {
+    primaryCtorMods :: [Mod],
+    primaryCtorName :: Name,
+    primaryCtorParamss :: [[ParamData]]}
+  deriving (Eq, Ord, Read, Show)
+
+_PrimaryCtor = Core.Name "hydra.scala.syntax.PrimaryCtor"
+
+_PrimaryCtor_mods = Core.Name "mods"
+
+_PrimaryCtor_name = Core.Name "name"
+
+_PrimaryCtor_paramss = Core.Name "paramss"
+
+data SecondaryCtor =
+  SecondaryCtor {
+    secondaryCtorMods :: [Mod],
+    secondaryCtorName :: Name,
+    secondaryCtorParamss :: [[ParamData]],
+    secondaryCtorInit :: Init,
+    secondaryCtorStats :: [Stat]}
+  deriving (Eq, Ord, Read, Show)
+
+_SecondaryCtor = Core.Name "hydra.scala.syntax.SecondaryCtor"
+
+_SecondaryCtor_mods = Core.Name "mods"
+
+_SecondaryCtor_name = Core.Name "name"
+
+_SecondaryCtor_paramss = Core.Name "paramss"
+
+_SecondaryCtor_init = Core.Name "init"
+
+_SecondaryCtor_stats = Core.Name "stats"
+
+data Init =
+  Init {
+    initTpe :: Type,
+    initName :: Name,
+    initArgss :: [[Data]]}
+  deriving (Eq, Ord, Read, Show)
+
+_Init = Core.Name "hydra.scala.syntax.Init"
+
+_Init_tpe = Core.Name "tpe"
+
+_Init_name = Core.Name "name"
+
+_Init_argss = Core.Name "argss"
+
+newtype Self =
+  Self {
+    unSelf :: ()}
+  deriving (Eq, Ord, Read, Show)
+
+_Self = Core.Name "hydra.scala.syntax.Self"
+
+data Template =
+  Template {
+    templateEarly :: [Stat],
+    templateInits :: [Init],
+    templateSelf :: Self,
+    templateStats :: [Stat]}
+  deriving (Eq, Ord, Read, Show)
+
+_Template = Core.Name "hydra.scala.syntax.Template"
+
+_Template_early = Core.Name "early"
+
+_Template_inits = Core.Name "inits"
+
+_Template_self = Core.Name "self"
+
+_Template_stats = Core.Name "stats"
+
+data Mod =
+  ModAnnot AnnotMod |
+  ModPrivate PrivateMod |
+  ModProtected ProtectedMod |
+  ModImplicit |
+  ModFinal |
+  ModSealed |
+  ModOpen |
+  ModSuper |
+  ModOverride |
+  ModCase |
+  ModAbstract |
+  ModCovariant |
+  ModContravariant |
+  ModLazy |
+  ModValParam |
+  ModVarParam |
+  ModInfix |
+  ModInline |
+  ModUsing |
+  ModOpaque |
+  ModTransparent
+  deriving (Eq, Ord, Read, Show)
+
+_Mod = Core.Name "hydra.scala.syntax.Mod"
+
+_Mod_annot = Core.Name "annot"
+
+_Mod_private = Core.Name "private"
+
+_Mod_protected = Core.Name "protected"
+
+_Mod_implicit = Core.Name "implicit"
+
+_Mod_final = Core.Name "final"
+
+_Mod_sealed = Core.Name "sealed"
+
+_Mod_open = Core.Name "open"
+
+_Mod_super = Core.Name "super"
+
+_Mod_override = Core.Name "override"
+
+_Mod_case = Core.Name "case"
+
+_Mod_abstract = Core.Name "abstract"
+
+_Mod_covariant = Core.Name "covariant"
+
+_Mod_contravariant = Core.Name "contravariant"
+
+_Mod_lazy = Core.Name "lazy"
+
+_Mod_valParam = Core.Name "valParam"
+
+_Mod_varParam = Core.Name "varParam"
+
+_Mod_infix = Core.Name "infix"
+
+_Mod_inline = Core.Name "inline"
+
+_Mod_using = Core.Name "using"
+
+_Mod_opaque = Core.Name "opaque"
+
+_Mod_transparent = Core.Name "transparent"
+
+data AnnotMod =
+  AnnotMod {
+    annotModInit :: Init}
+  deriving (Eq, Ord, Read, Show)
+
+_AnnotMod = Core.Name "hydra.scala.syntax.AnnotMod"
+
+_AnnotMod_init = Core.Name "init"
+
+data PrivateMod =
+  PrivateMod {
+    privateModWithin :: Ref}
+  deriving (Eq, Ord, Read, Show)
+
+_PrivateMod = Core.Name "hydra.scala.syntax.PrivateMod"
+
+_PrivateMod_within = Core.Name "within"
+
+data ProtectedMod =
+  ProtectedMod {
+    protectedModWithin :: Ref}
+  deriving (Eq, Ord, Read, Show)
+
+_ProtectedMod = Core.Name "hydra.scala.syntax.ProtectedMod"
+
+_ProtectedMod_within = Core.Name "within"
+
+data Enumerator =
+  EnumeratorGenerator GeneratorEnumerator |
+  EnumeratorCaseGenerator CaseGeneratorEnumerator |
+  EnumeratorVal ValEnumerator |
+  EnumeratorGuard GuardEnumerator
+  deriving (Eq, Ord, Read, Show)
+
+_Enumerator = Core.Name "hydra.scala.syntax.Enumerator"
+
+_Enumerator_generator = Core.Name "generator"
+
+_Enumerator_caseGenerator = Core.Name "caseGenerator"
+
+_Enumerator_val = Core.Name "val"
+
+_Enumerator_guard = Core.Name "guard"
+
+data GeneratorEnumerator =
+  GeneratorEnumerator {
+    generatorEnumeratorPat :: Pat,
+    generatorEnumeratorRhs :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_GeneratorEnumerator = Core.Name "hydra.scala.syntax.GeneratorEnumerator"
+
+_GeneratorEnumerator_pat = Core.Name "pat"
+
+_GeneratorEnumerator_rhs = Core.Name "rhs"
+
+data CaseGeneratorEnumerator =
+  CaseGeneratorEnumerator {
+    caseGeneratorEnumeratorPat :: Pat,
+    caseGeneratorEnumeratorRhs :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_CaseGeneratorEnumerator = Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"
+
+_CaseGeneratorEnumerator_pat = Core.Name "pat"
+
+_CaseGeneratorEnumerator_rhs = Core.Name "rhs"
+
+data ValEnumerator =
+  ValEnumerator {
+    valEnumeratorPat :: Pat,
+    valEnumeratorRhs :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_ValEnumerator = Core.Name "hydra.scala.syntax.ValEnumerator"
+
+_ValEnumerator_pat = Core.Name "pat"
+
+_ValEnumerator_rhs = Core.Name "rhs"
+
+data GuardEnumerator =
+  GuardEnumerator {
+    guardEnumeratorCond :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_GuardEnumerator = Core.Name "hydra.scala.syntax.GuardEnumerator"
+
+_GuardEnumerator_cond = Core.Name "cond"
+
+data ImportExportStat =
+  ImportExportStatImport Import |
+  ImportExportStatExport Export
+  deriving (Eq, Ord, Read, Show)
+
+_ImportExportStat = Core.Name "hydra.scala.syntax.ImportExportStat"
+
+_ImportExportStat_import = Core.Name "import"
+
+_ImportExportStat_export = Core.Name "export"
+
+data Import =
+  Import {
+    importImporters :: [Importer]}
+  deriving (Eq, Ord, Read, Show)
+
+_Import = Core.Name "hydra.scala.syntax.Import"
+
+_Import_importers = Core.Name "importers"
+
+data Export =
+  Export {
+    exportImporters :: [Importer]}
+  deriving (Eq, Ord, Read, Show)
+
+_Export = Core.Name "hydra.scala.syntax.Export"
+
+_Export_importers = Core.Name "importers"
+
+data Importer =
+  Importer {
+    importerRef :: RefData,
+    importerImportees :: [Importee]}
+  deriving (Eq, Ord, Read, Show)
+
+_Importer = Core.Name "hydra.scala.syntax.Importer"
+
+_Importer_ref = Core.Name "ref"
+
+_Importer_importees = Core.Name "importees"
+
+data Importee =
+  ImporteeWildcard |
+  ImporteeGiven GivenImportee |
+  ImporteeGivenAll |
+  ImporteeName NameImportee |
+  ImporteeRename RenameImportee |
+  ImporteeUnimport UnimportImportee
+  deriving (Eq, Ord, Read, Show)
+
+_Importee = Core.Name "hydra.scala.syntax.Importee"
+
+_Importee_wildcard = Core.Name "wildcard"
+
+_Importee_given = Core.Name "given"
+
+_Importee_givenAll = Core.Name "givenAll"
+
+_Importee_name = Core.Name "name"
+
+_Importee_rename = Core.Name "rename"
+
+_Importee_unimport = Core.Name "unimport"
+
+data GivenImportee =
+  GivenImportee {
+    givenImporteeTpe :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_GivenImportee = Core.Name "hydra.scala.syntax.GivenImportee"
+
+_GivenImportee_tpe = Core.Name "tpe"
+
+data NameImportee =
+  NameImportee {
+    nameImporteeName :: Name}
+  deriving (Eq, Ord, Read, Show)
+
+_NameImportee = Core.Name "hydra.scala.syntax.NameImportee"
+
+_NameImportee_name = Core.Name "name"
+
+data RenameImportee =
+  RenameImportee {
+    renameImporteeName :: Name,
+    renameImporteeRename :: Name}
+  deriving (Eq, Ord, Read, Show)
+
+_RenameImportee = Core.Name "hydra.scala.syntax.RenameImportee"
+
+_RenameImportee_name = Core.Name "name"
+
+_RenameImportee_rename = Core.Name "rename"
+
+data UnimportImportee =
+  UnimportImportee {
+    unimportImporteeName :: Name}
+  deriving (Eq, Ord, Read, Show)
+
+_UnimportImportee = Core.Name "hydra.scala.syntax.UnimportImportee"
+
+_UnimportImportee_name = Core.Name "name"
+
+data CaseTree =
+  CaseTreeCase Case |
+  CaseTreeTypeCase TypeCase
+  deriving (Eq, Ord, Read, Show)
+
+_CaseTree = Core.Name "hydra.scala.syntax.CaseTree"
+
+_CaseTree_case = Core.Name "case"
+
+_CaseTree_typeCase = Core.Name "typeCase"
+
+data Case =
+  Case {
+    casePat :: Pat,
+    caseCond :: (Maybe Data),
+    caseBody :: Data}
+  deriving (Eq, Ord, Read, Show)
+
+_Case = Core.Name "hydra.scala.syntax.Case"
+
+_Case_pat = Core.Name "pat"
+
+_Case_cond = Core.Name "cond"
+
+_Case_body = Core.Name "body"
+
+data TypeCase =
+  TypeCase {
+    typeCasePat :: Type,
+    typeCaseBody :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_TypeCase = Core.Name "hydra.scala.syntax.TypeCase"
+
+_TypeCase_pat = Core.Name "pat"
+
+_TypeCase_body = Core.Name "body"
+
+data Source =
+  Source {
+    sourceStats :: [Stat]}
+  deriving (Eq, Ord, Read, Show)
+
+_Source = Core.Name "hydra.scala.syntax.Source"
+
+_Source_stats = Core.Name "stats"
diff --git a/src/main/haskell/Hydra/Scala/Utils.hs b/src/main/haskell/Hydra/Scala/Utils.hs
new file mode 100644
--- /dev/null
+++ b/src/main/haskell/Hydra/Scala/Utils.hs
@@ -0,0 +1,232 @@
+-- Note: this is an automatically generated file. Do not edit.
+
+-- | Utility functions for constructing Scala AST nodes
+
+module Hydra.Scala.Utils where
+
+import qualified Hydra.Ast as Ast
+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.File as ErrorFile
+import qualified Hydra.Error.Packaging as ErrorPackaging
+import qualified Hydra.Error.System as ErrorSystem
+import qualified Hydra.Errors as Errors
+import qualified Hydra.File as File
+import qualified Hydra.Formatting as Formatting
+import qualified Hydra.Graph as Graph
+import qualified Hydra.Json.Model as Model
+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic
+import qualified Hydra.Overlay.Haskell.Lib.Math as Math
+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
+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.Scala.Language as Language
+import qualified Hydra.Scala.Syntax as Syntax
+import qualified Hydra.Strip as Strip
+import qualified Hydra.System as System
+import qualified Hydra.Tabular as Tabular
+import qualified Hydra.Testing as Testing
+import qualified Hydra.Time as Time
+import qualified Hydra.Topology as Topology
+import qualified Hydra.Typed as Typed
+import qualified Hydra.Typing as Typing
+import qualified Hydra.Util as Util
+import qualified Hydra.Validation as Validation
+import qualified Hydra.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
+
+-- | Extract the name from a type, if it is a named type
+nameOfType :: t0 -> Core.Type -> Maybe Core.Name
+nameOfType cx t =
+    case (Strip.deannotateType t) of
+      Core.TypeVariable v0 -> Just v0
+      Core.TypeForall v0 -> nameOfType cx (Core.forallTypeBody v0)
+      _ -> Nothing
+
+-- | Qualify a union field name, optionally prefixing with the Scala type name
+qualifyUnionFieldName :: String -> Maybe Core.Name -> Core.Name -> String
+qualifyUnionFieldName dlft sname fname =
+    Strings.cat2 (Optionals.cases sname dlft (\n -> Strings.cat2 (scalaTypeName True n) ".")) (scalaEscapeName (Core.unName fname))
+
+-- | Apply a Scala data expression to a list of arguments
+sapply :: Syntax.Data -> [Syntax.Data] -> Syntax.Data
+sapply fun args =
+    Syntax.DataApply (Syntax.ApplyData {
+      Syntax.applyDataFun = fun,
+      Syntax.applyDataArgs = args})
+
+-- | Apply explicit type parameters to a Scala expression (e.g. f[A, B])
+sapplyTypes :: Syntax.Data -> [Syntax.Type] -> Syntax.Data
+sapplyTypes fun typeArgs =
+
+      let typeToStr = \t -> typeToString t
+          typeStrings = Lists.map typeToStr typeArgs
+          typeArgStr =
+                  Strings.cat [
+                    "[",
+                    (Strings.intercalate ", " typeStrings),
+                    "]"]
+      in case fun of
+        Syntax.DataRef v0 -> case v0 of
+          Syntax.RefDataName v1 ->
+            let nameStr = Syntax.nameDataValue v1
+                rawName = Syntax.unPredefString nameStr
+            in (sname (Strings.cat2 rawName typeArgStr))
+          Syntax.RefDataSelect v1 ->
+            let qual = Syntax.selectDataQual v1
+                selName = Syntax.selectDataName v1
+                nameStr = Syntax.nameDataValue selName
+                rawName = Syntax.unPredefString nameStr
+            in (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {
+              Syntax.selectDataQual = qual,
+              Syntax.selectDataName = Syntax.NameData {
+                Syntax.nameDataValue = (Syntax.PredefString (Strings.cat2 rawName typeArgStr))}})))
+          _ -> fun
+        _ -> fun
+
+-- | Create a Scala assignment expression
+sassign :: Syntax.Data -> Syntax.Data -> Syntax.Data
+sassign lhs rhs =
+    Syntax.DataAssign (Syntax.AssignData {
+      Syntax.assignDataLhs = lhs,
+      Syntax.assignDataRhs = rhs})
+
+-- | Like scalaEscapeName, but also renames 'values' to 'values_' to avoid conflict with Scala 3 enum's synthesized values() method
+scalaEscapeEnumCaseName :: String -> String
+scalaEscapeEnumCaseName s =
+
+      let renamed = Logic.ifElse (Equality.equal s "values") "values_" s
+      in (scalaEscapeName renamed)
+
+-- | Sanitize a name for Scala: escape reserved words, replace invalid characters
+scalaEscapeName :: String -> String
+scalaEscapeName s =
+
+      let sanitized = Strings.fromList (Lists.map (\c -> Logic.ifElse (Equality.equal c 39) 95 c) (Strings.toList s))
+          sanitized2 = Logic.ifElse (Equality.equal sanitized "_") "_x" sanitized
+          sanitized3 = Logic.ifElse (Equality.equal sanitized2 "toString") "toString_" sanitized2
+          needsBackticks =
+                  Logic.or (Sets.member sanitized3 scalaReservedWords) (Logic.and (Equality.gt (Strings.length sanitized3) 0) (Equality.equal (Optionals.fromOptional 0 (Strings.maybeCharAt (Math.sub (Strings.length sanitized3) 1) sanitized3)) 95))
+      in (Logic.ifElse needsBackticks (Strings.cat [
+        "`",
+        sanitized3,
+        "`"]) sanitized3)
+
+-- | Reference to scalaReservedWords from the language module
+scalaReservedWords :: S.Set String
+scalaReservedWords = Language.scalaReservedWords
+
+-- | Convert a Hydra name to a Scala type name
+scalaTypeName :: Bool -> Core.Name -> String
+scalaTypeName qualify name =
+    Logic.ifElse (Logic.or qualify (Sets.member (Names.localNameOf name) scalaReservedWords)) (Core.unName name) (Names.localNameOf name)
+
+-- | Create a Scala lambda (function) expression
+slambda :: String -> Syntax.Data -> Maybe Syntax.Type -> Syntax.Data
+slambda v body sdom =
+    Syntax.DataFunction (Syntax.FunctionData {
+      Syntax.functionDataParams = [
+        Syntax.ParamData {
+          Syntax.paramDataMods = [],
+          Syntax.paramDataName = (Syntax.NameValue v),
+          Syntax.paramDataDecltpe = sdom,
+          Syntax.paramDataDefault = Nothing}],
+      Syntax.functionDataBody = body})
+
+-- | Create a Scala name reference
+sname :: String -> Syntax.Data
+sname s = Syntax.DataRef (Syntax.RefDataName (Syntax.NameData {
+  Syntax.nameDataValue = (Syntax.PredefString s)}))
+
+-- | Create a Scala primitive reference from a Hydra name
+sprim :: Core.Name -> Syntax.Data
+sprim name =
+
+      let qname = Names.qualifyName name
+          prefix = Packaging.unModuleName (Optionals.fromOptional (Packaging.ModuleName "") (Util.qualifiedNameModuleName qname))
+          local = scalaEscapeName (Util.qualifiedNameLocal qname)
+      in (sname (Strings.cat2 (Strings.cat2 prefix ".") local))
+
+-- | Apply a Scala type to a list of type arguments
+stapply :: Syntax.Type -> [Syntax.Type] -> Syntax.Type
+stapply t args =
+    Syntax.TypeApply (Syntax.ApplyType {
+      Syntax.applyTypeTpe = t,
+      Syntax.applyTypeArgs = args})
+
+-- | Apply a Scala type to one type argument
+stapply1 :: Syntax.Type -> Syntax.Type -> Syntax.Type
+stapply1 t1 t2 = stapply t1 [
+  t2]
+
+-- | Apply a Scala type to two type arguments
+stapply2 :: Syntax.Type -> Syntax.Type -> Syntax.Type -> Syntax.Type
+stapply2 t1 t2 t3 =
+    stapply t1 [
+      t2,
+      t3]
+
+-- | Create a Scala type parameter from a Hydra name, capitalizing to avoid collision with value params
+stparam :: Core.Name -> Syntax.ParamType
+stparam name =
+
+      let v = Formatting.capitalize (Core.unName name)
+      in Syntax.ParamType {
+        Syntax.paramTypeMods = [],
+        Syntax.paramTypeName = (Syntax.NameValue v),
+        Syntax.paramTypeTparams = [],
+        Syntax.paramTypeTbounds = [],
+        Syntax.paramTypeVbounds = [],
+        Syntax.paramTypeCbounds = []}
+
+-- | Create a Scala type reference by name
+stref :: String -> Syntax.Type
+stref s = Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {
+  Syntax.nameTypeValue = s}))
+
+-- | Create a Scala pattern variable
+svar :: Core.Name -> Syntax.Pat
+svar name =
+
+      let v = Core.unName name
+      in (Syntax.PatVar (Syntax.VarPat {
+        Syntax.varPatName = Syntax.NameData {
+          Syntax.nameDataValue = (Syntax.PredefString v)}}))
+
+-- | Convert a Scala type to its string representation
+typeToString :: Syntax.Type -> String
+typeToString t =
+    case t of
+      Syntax.TypeRef v0 -> case v0 of
+        Syntax.RefTypeName v1 -> Syntax.nameTypeValue v1
+        _ -> "Any"
+      Syntax.TypeVar v0 -> Syntax.nameTypeValue (Syntax.varTypeName v0)
+      Syntax.TypeFunction v0 ->
+        let params = Lists.map typeToString (Syntax.functionTypeParams v0)
+            res = typeToString (Syntax.functionTypeRes v0)
+        in (Strings.cat [
+          "(",
+          (Strings.intercalate ", " params),
+          ") => ",
+          res])
+      Syntax.TypeApply v0 ->
+        let base = typeToString (Syntax.applyTypeTpe v0)
+            argStrs = Lists.map typeToString (Syntax.applyTypeArgs v0)
+        in (Strings.cat [
+          base,
+          "[",
+          (Strings.intercalate ", " argStrs),
+          "]"])
+      _ -> "Any"