hydra-python (empty) → 0.17.0

raw patch · 14 files changed

+25151/−0 lines, 14 filesdep +basedep +containersdep +hydra-kernel

Dependencies added: base, containers, hydra-kernel, scientific

Files

• CHANGELOG.md +1372/−0
• LICENSE +201/−0
• NOTICE +3/−0
• hydra-python.cabal +49/−0
• src/main/haskell/Hydra/Dsl/Python/Environment.hs +4617/−0
• src/main/haskell/Hydra/Dsl/Python/Syntax.hs +10946/−0
• src/main/haskell/Hydra/Python/Coder.hs +2965/−0
• src/main/haskell/Hydra/Python/Environment.hs +154/−0
• src/main/haskell/Hydra/Python/Language.hs +172/−0
• src/main/haskell/Hydra/Python/Names.hs +194/−0
• src/main/haskell/Hydra/Python/Serde.hs +1076/−0
• src/main/haskell/Hydra/Python/Syntax.hs +2502/−0
• src/main/haskell/Hydra/Python/Testing.hs +135/−0
• src/main/haskell/Hydra/Python/Utils.hs +765/−0

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

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

@@ -0,0 +1,3 @@+Hydra+Copyright 2021-2026 The Hydra authors+https://github.com/CategoricalData/hydra

@@ -0,0 +1,49 @@+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-python+version:        0.17.0+synopsis:       Hydra's Python coder: emit Python 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". Python 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.Python.Environment+      Hydra.Dsl.Python.Syntax+      Hydra.Python.Coder+      Hydra.Python.Environment+      Hydra.Python.Language+      Hydra.Python.Names+      Hydra.Python.Serde+      Hydra.Python.Syntax+      Hydra.Python.Testing+      Hydra.Python.Utils+  other-modules:+      Paths_hydra_python+  hs-source-dirs:+      src/main/haskell+  build-depends:+      base >=4.19.0 && <4.22+    , containers >=0.6.7 && <0.8+    , hydra-kernel ==0.17.0+    , scientific >=0.3.7 && <0.4+  default-language: Haskell2010

@@ -0,0 +1,4617 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.python.environment++module Hydra.Dsl.Python.Environment where++import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Graph as DslGraph+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Dsl.Python.Syntax as PythonSyntax+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Graph as Graph+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Python.Environment as Environment+import qualified Hydra.Python.Syntax as Syntax+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S++-- | DSL constructor for hydra.python.environment.PyGraph+pyGraph :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Environment.PyGraph+pyGraph graph metadata =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PyGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm graph)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm metadata)}]}))++-- | DSL accessor for the graph field of hydra.python.environment.PyGraph+pyGraphGraph :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Graph.Graph+pyGraphGraph x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PyGraph"),+        Core.projectionFieldName = (Core.Name "graph")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the metadata field of hydra.python.environment.PyGraph+pyGraphMetadata :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Environment.PythonModuleMetadata+pyGraphMetadata x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PyGraph"),+        Core.projectionFieldName = (Core.Name "metadata")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the graph field of hydra.python.environment.PyGraph+pyGraphWithGraph :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.PyGraph+pyGraphWithGraph original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PyGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PyGraph"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the metadata field of hydra.python.environment.PyGraph+pyGraphWithMetadata :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Environment.PyGraph+pyGraphWithMetadata original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PyGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PyGraph"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.environment.PythonEnvironment+pythonEnvironment :: Typed.TypedTerm (Util.ModuleNames Syntax.DottedName) -> Typed.TypedTerm ([Core.Name], (M.Map Core.Name Syntax.Name)) -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.PythonVersion -> Typed.TypedTerm Bool -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.PythonEnvironment+pythonEnvironment namespaces boundTypeVariables graph nullaryBindings version skipCasts inlineVariables =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Typed.unTypedTerm namespaces)},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypeVariables"),+          Core.fieldTerm = (Typed.unTypedTerm boundTypeVariables)},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm graph)},+        Core.Field {+          Core.fieldName = (Core.Name "nullaryBindings"),+          Core.fieldTerm = (Typed.unTypedTerm nullaryBindings)},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Typed.unTypedTerm version)},+        Core.Field {+          Core.fieldName = (Core.Name "skipCasts"),+          Core.fieldTerm = (Typed.unTypedTerm skipCasts)},+        Core.Field {+          Core.fieldName = (Core.Name "inlineVariables"),+          Core.fieldTerm = (Typed.unTypedTerm inlineVariables)}]}))++-- | DSL accessor for the boundTypeVariables field of hydra.python.environment.PythonEnvironment+pythonEnvironmentBoundTypeVariables :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm ([Core.Name], (M.Map Core.Name Syntax.Name))+pythonEnvironmentBoundTypeVariables x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+        Core.projectionFieldName = (Core.Name "boundTypeVariables")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the graph field of hydra.python.environment.PythonEnvironment+pythonEnvironmentGraph :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Graph.Graph+pythonEnvironmentGraph x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+        Core.projectionFieldName = (Core.Name "graph")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the inlineVariables field of hydra.python.environment.PythonEnvironment+pythonEnvironmentInlineVariables :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set Core.Name)+pythonEnvironmentInlineVariables x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+        Core.projectionFieldName = (Core.Name "inlineVariables")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the namespaces field of hydra.python.environment.PythonEnvironment+pythonEnvironmentNamespaces :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName)+pythonEnvironmentNamespaces x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+        Core.projectionFieldName = (Core.Name "namespaces")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the nullaryBindings field of hydra.python.environment.PythonEnvironment+pythonEnvironmentNullaryBindings :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set Core.Name)+pythonEnvironmentNullaryBindings x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+        Core.projectionFieldName = (Core.Name "nullaryBindings")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the skipCasts field of hydra.python.environment.PythonEnvironment+pythonEnvironmentSkipCasts :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Bool+pythonEnvironmentSkipCasts x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+        Core.projectionFieldName = (Core.Name "skipCasts")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the version field of hydra.python.environment.PythonEnvironment+pythonEnvironmentVersion :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Environment.PythonVersion+pythonEnvironmentVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+        Core.projectionFieldName = (Core.Name "version")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the boundTypeVariables field of hydra.python.environment.PythonEnvironment+pythonEnvironmentWithBoundTypeVariables :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm ([Core.Name], (M.Map Core.Name Syntax.Name)) -> Typed.TypedTerm Environment.PythonEnvironment+pythonEnvironmentWithBoundTypeVariables original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypeVariables"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nullaryBindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "nullaryBindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "version")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "skipCasts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "skipCasts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inlineVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "inlineVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the graph field of hydra.python.environment.PythonEnvironment+pythonEnvironmentWithGraph :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.PythonEnvironment+pythonEnvironmentWithGraph original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "boundTypeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "nullaryBindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "nullaryBindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "version")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "skipCasts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "skipCasts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inlineVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "inlineVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the inlineVariables field of hydra.python.environment.PythonEnvironment+pythonEnvironmentWithInlineVariables :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.PythonEnvironment+pythonEnvironmentWithInlineVariables original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "boundTypeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nullaryBindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "nullaryBindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "version")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "skipCasts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "skipCasts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inlineVariables"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the namespaces field of hydra.python.environment.PythonEnvironment+pythonEnvironmentWithNamespaces :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName) -> Typed.TypedTerm Environment.PythonEnvironment+pythonEnvironmentWithNamespaces original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "boundTypeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nullaryBindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "nullaryBindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "version")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "skipCasts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "skipCasts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inlineVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "inlineVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the nullaryBindings field of hydra.python.environment.PythonEnvironment+pythonEnvironmentWithNullaryBindings :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.PythonEnvironment+pythonEnvironmentWithNullaryBindings original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "boundTypeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nullaryBindings"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "version")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "skipCasts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "skipCasts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inlineVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "inlineVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the skipCasts field of hydra.python.environment.PythonEnvironment+pythonEnvironmentWithSkipCasts :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonEnvironment+pythonEnvironmentWithSkipCasts original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "boundTypeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nullaryBindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "nullaryBindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "version")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "skipCasts"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "inlineVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "inlineVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the version field of hydra.python.environment.PythonEnvironment+pythonEnvironmentWithVersion :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Environment.PythonVersion -> Typed.TypedTerm Environment.PythonEnvironment+pythonEnvironmentWithVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "boundTypeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nullaryBindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "nullaryBindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "skipCasts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "skipCasts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inlineVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonEnvironment"),+              Core.projectionFieldName = (Core.Name "inlineVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.environment.PythonModuleMetadata+pythonModuleMetadata :: Typed.TypedTerm (Util.ModuleNames Syntax.DottedName) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadata namespaces typeVariables usesAnnotated usesCallable usesCast usesLruCache usesTypeAlias usesDataclass usesDecimal usesEither usesEnum usesFrozenDict usesFrozenList usesFrozenSet usesGeneric usesJust usesLeft usesMaybe usesName usesNode usesNothing usesRight usesTypeVar =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Typed.unTypedTerm namespaces)},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Typed.unTypedTerm typeVariables)},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Typed.unTypedTerm usesAnnotated)},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Typed.unTypedTerm usesCallable)},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Typed.unTypedTerm usesCast)},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Typed.unTypedTerm usesLruCache)},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Typed.unTypedTerm usesTypeAlias)},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Typed.unTypedTerm usesDataclass)},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Typed.unTypedTerm usesDecimal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Typed.unTypedTerm usesEither)},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Typed.unTypedTerm usesEnum)},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Typed.unTypedTerm usesFrozenDict)},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Typed.unTypedTerm usesFrozenList)},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Typed.unTypedTerm usesFrozenSet)},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Typed.unTypedTerm usesGeneric)},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Typed.unTypedTerm usesJust)},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Typed.unTypedTerm usesLeft)},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Typed.unTypedTerm usesMaybe)},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Typed.unTypedTerm usesName)},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Typed.unTypedTerm usesNode)},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Typed.unTypedTerm usesNothing)},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Typed.unTypedTerm usesRight)},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Typed.unTypedTerm usesTypeVar)}]}))++-- | DSL accessor for the namespaces field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataNamespaces :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName)+pythonModuleMetadataNamespaces x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "namespaces")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeVariables field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataTypeVariables :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (S.Set Core.Name)+pythonModuleMetadataTypeVariables x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "typeVariables")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesAnnotated field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesAnnotated :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesAnnotated x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesAnnotated")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesCallable field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesCallable :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesCallable x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesCallable")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesCast field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesCast :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesCast x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesCast")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesDataclass field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesDataclass :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesDataclass x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesDataclass")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesDecimal field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesDecimal :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesDecimal x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesDecimal")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesEither field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesEither :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesEither x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesEither")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesEnum field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesEnum :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesEnum x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesEnum")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesFrozenDict field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesFrozenDict :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesFrozenDict x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesFrozenList field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesFrozenList :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesFrozenList x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesFrozenList")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesFrozenSet field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesFrozenSet :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesFrozenSet x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesGeneric field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesGeneric :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesGeneric x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesGeneric")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesJust field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesJust :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesJust x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesJust")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesLeft field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesLeft :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesLeft x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesLeft")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesLruCache field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesLruCache :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesLruCache x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesLruCache")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesMaybe field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesMaybe :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesMaybe x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesMaybe")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesName field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesName :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesNode field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesNode :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesNode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesNode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesNothing field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesNothing :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesNothing x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesNothing")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesRight field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesRight :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesRight x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesRight")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesTypeAlias field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesTypeAlias :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesTypeAlias x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the usesTypeVar field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataUsesTypeVar :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool+pythonModuleMetadataUsesTypeVar x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+        Core.projectionFieldName = (Core.Name "usesTypeVar")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the namespaces field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithNamespaces :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName) -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithNamespaces original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeVariables field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithTypeVariables :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithTypeVariables original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesAnnotated field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesAnnotated :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesAnnotated original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesCallable field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesCallable :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesCallable original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesCast field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesCast :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesCast original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesDataclass field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesDataclass :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesDataclass original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesDecimal field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesDecimal :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesDecimal original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesEither field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesEither :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesEither original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesEnum field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesEnum :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesEnum original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesFrozenDict field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesFrozenDict :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesFrozenDict original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesFrozenList field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesFrozenList :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesFrozenList original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesFrozenSet field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesFrozenSet :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesFrozenSet original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesGeneric field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesGeneric :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesGeneric original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesJust field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesJust :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesJust original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesLeft field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesLeft :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesLeft original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesLruCache field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesLruCache :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesLruCache original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesMaybe field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesMaybe :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesMaybe original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesName field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesName :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesNode field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesNode :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesNode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesNothing field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesNothing :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesNothing original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesRight field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesRight :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesRight original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesTypeAlias field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesTypeAlias :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesTypeAlias original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeVar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the usesTypeVar field of hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataWithUsesTypeVar :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata+pythonModuleMetadataWithUsesTypeVar original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "namespaces"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "namespaces")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesAnnotated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesAnnotated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCallable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCallable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesCast"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesCast")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLruCache"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLruCache")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeAlias"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesTypeAlias")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDataclass"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDataclass")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesDecimal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesDecimal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEither"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEither")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesEnum"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesEnum")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenDict"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenDict")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenList"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenList")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesFrozenSet"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesFrozenSet")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesGeneric"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesGeneric")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesJust"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesJust")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesLeft"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesLeft")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesMaybe"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesMaybe")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesNothing"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesNothing")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesRight"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.environment.PythonModuleMetadata"),+              Core.projectionFieldName = (Core.Name "usesRight")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "usesTypeVar"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the python310 variant of hydra.python.environment.PythonVersion+pythonVersionPython310 :: Typed.TypedTerm Environment.PythonVersion+pythonVersionPython310 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.environment.PythonVersion"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "python310"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the python312 variant of hydra.python.environment.PythonVersion+pythonVersionPython312 :: Typed.TypedTerm Environment.PythonVersion+pythonVersionPython312 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.environment.PythonVersion"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "python312"),+        Core.fieldTerm = Core.TermUnit}}))

@@ -0,0 +1,10946 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.python.syntax++module Hydra.Dsl.Python.Syntax where++import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Python.Syntax as Syntax+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++-- | DSL injection for the star variant of hydra.python.syntax.AnnotatedRhs+annotatedRhsStar :: Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm Syntax.AnnotatedRhs+annotatedRhsStar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AnnotatedRhs"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "star"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the yield variant of hydra.python.syntax.AnnotatedRhs+annotatedRhsYield :: Typed.TypedTerm Syntax.YieldExpression -> Typed.TypedTerm Syntax.AnnotatedRhs+annotatedRhsYield x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AnnotatedRhs"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "yield"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.AnnotatedStatement+annotatedStatement :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.AnnotatedStatement+annotatedStatement comment statement =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AnnotatedStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "comment"),+          Core.fieldTerm = (Typed.unTypedTerm comment)},+        Core.Field {+          Core.fieldName = (Core.Name "statement"),+          Core.fieldTerm = (Typed.unTypedTerm statement)}]}))++-- | DSL accessor for the comment field of hydra.python.syntax.AnnotatedStatement+annotatedStatementComment :: Typed.TypedTerm Syntax.AnnotatedStatement -> Typed.TypedTerm String+annotatedStatementComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AnnotatedStatement"),+        Core.projectionFieldName = (Core.Name "comment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the statement field of hydra.python.syntax.AnnotatedStatement+annotatedStatementStatement :: Typed.TypedTerm Syntax.AnnotatedStatement -> Typed.TypedTerm Syntax.Statement+annotatedStatementStatement x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AnnotatedStatement"),+        Core.projectionFieldName = (Core.Name "statement")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the comment field of hydra.python.syntax.AnnotatedStatement+annotatedStatementWithComment :: Typed.TypedTerm Syntax.AnnotatedStatement -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.AnnotatedStatement+annotatedStatementWithComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AnnotatedStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "comment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "statement"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AnnotatedStatement"),+              Core.projectionFieldName = (Core.Name "statement")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the statement field of hydra.python.syntax.AnnotatedStatement+annotatedStatementWithStatement :: Typed.TypedTerm Syntax.AnnotatedStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.AnnotatedStatement+annotatedStatementWithStatement original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AnnotatedStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "comment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AnnotatedStatement"),+              Core.projectionFieldName = (Core.Name "comment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "statement"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.python.syntax.Annotation wrapper+annotation :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Annotation+annotation x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Annotation"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.Args+args :: Typed.TypedTerm [Syntax.PosArg] -> Typed.TypedTerm [Syntax.KwargOrStarred] -> Typed.TypedTerm [Syntax.KwargOrDoubleStarred] -> Typed.TypedTerm Syntax.Args+args positional kwargOrStarred kwargOrDoubleStarred =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Args"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "positional"),+          Core.fieldTerm = (Typed.unTypedTerm positional)},+        Core.Field {+          Core.fieldName = (Core.Name "kwargOrStarred"),+          Core.fieldTerm = (Typed.unTypedTerm kwargOrStarred)},+        Core.Field {+          Core.fieldName = (Core.Name "kwargOrDoubleStarred"),+          Core.fieldTerm = (Typed.unTypedTerm kwargOrDoubleStarred)}]}))++-- | DSL accessor for the kwargOrDoubleStarred field of hydra.python.syntax.Args+argsKwargOrDoubleStarred :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm [Syntax.KwargOrDoubleStarred]+argsKwargOrDoubleStarred x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+        Core.projectionFieldName = (Core.Name "kwargOrDoubleStarred")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the kwargOrStarred field of hydra.python.syntax.Args+argsKwargOrStarred :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm [Syntax.KwargOrStarred]+argsKwargOrStarred x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+        Core.projectionFieldName = (Core.Name "kwargOrStarred")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the positional field of hydra.python.syntax.Args+argsPositional :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm [Syntax.PosArg]+argsPositional x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+        Core.projectionFieldName = (Core.Name "positional")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the kwargOrDoubleStarred field of hydra.python.syntax.Args+argsWithKwargOrDoubleStarred :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm [Syntax.KwargOrDoubleStarred] -> Typed.TypedTerm Syntax.Args+argsWithKwargOrDoubleStarred original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Args"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "positional"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+              Core.projectionFieldName = (Core.Name "positional")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "kwargOrStarred"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+              Core.projectionFieldName = (Core.Name "kwargOrStarred")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "kwargOrDoubleStarred"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the kwargOrStarred field of hydra.python.syntax.Args+argsWithKwargOrStarred :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm [Syntax.KwargOrStarred] -> Typed.TypedTerm Syntax.Args+argsWithKwargOrStarred original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Args"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "positional"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+              Core.projectionFieldName = (Core.Name "positional")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "kwargOrStarred"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "kwargOrDoubleStarred"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+              Core.projectionFieldName = (Core.Name "kwargOrDoubleStarred")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the positional field of hydra.python.syntax.Args+argsWithPositional :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm [Syntax.PosArg] -> Typed.TypedTerm Syntax.Args+argsWithPositional original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Args"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "positional"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "kwargOrStarred"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+              Core.projectionFieldName = (Core.Name "kwargOrStarred")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "kwargOrDoubleStarred"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Args"),+              Core.projectionFieldName = (Core.Name "kwargOrDoubleStarred")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.AsPattern+asPattern :: Typed.TypedTerm Syntax.OrPattern -> Typed.TypedTerm Syntax.PatternCaptureTarget -> Typed.TypedTerm Syntax.AsPattern+asPattern pattern as =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AsPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "pattern"),+          Core.fieldTerm = (Typed.unTypedTerm pattern)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm as)}]}))++-- | DSL accessor for the as field of hydra.python.syntax.AsPattern+asPatternAs :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.PatternCaptureTarget+asPatternAs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AsPattern"),+        Core.projectionFieldName = (Core.Name "as")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the pattern field of hydra.python.syntax.AsPattern+asPatternPattern :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.OrPattern+asPatternPattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AsPattern"),+        Core.projectionFieldName = (Core.Name "pattern")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the as field of hydra.python.syntax.AsPattern+asPatternWithAs :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.PatternCaptureTarget -> Typed.TypedTerm Syntax.AsPattern+asPatternWithAs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AsPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "pattern"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AsPattern"),+              Core.projectionFieldName = (Core.Name "pattern")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the pattern field of hydra.python.syntax.AsPattern+asPatternWithPattern :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.OrPattern -> Typed.TypedTerm Syntax.AsPattern+asPatternWithPattern original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AsPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "pattern"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AsPattern"),+              Core.projectionFieldName = (Core.Name "as")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.AssertStatement+assertStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.AssertStatement+assertStatement expression1 expression2 =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AssertStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression1"),+          Core.fieldTerm = (Typed.unTypedTerm expression1)},+        Core.Field {+          Core.fieldName = (Core.Name "expression2"),+          Core.fieldTerm = (Typed.unTypedTerm expression2)}]}))++-- | DSL accessor for the expression1 field of hydra.python.syntax.AssertStatement+assertStatementExpression1 :: Typed.TypedTerm Syntax.AssertStatement -> Typed.TypedTerm Syntax.Expression+assertStatementExpression1 x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AssertStatement"),+        Core.projectionFieldName = (Core.Name "expression1")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expression2 field of hydra.python.syntax.AssertStatement+assertStatementExpression2 :: Typed.TypedTerm Syntax.AssertStatement -> Typed.TypedTerm (Maybe Syntax.Expression)+assertStatementExpression2 x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AssertStatement"),+        Core.projectionFieldName = (Core.Name "expression2")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expression1 field of hydra.python.syntax.AssertStatement+assertStatementWithExpression1 :: Typed.TypedTerm Syntax.AssertStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssertStatement+assertStatementWithExpression1 original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AssertStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression1"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "expression2"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AssertStatement"),+              Core.projectionFieldName = (Core.Name "expression2")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the expression2 field of hydra.python.syntax.AssertStatement+assertStatementWithExpression2 :: Typed.TypedTerm Syntax.AssertStatement -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.AssertStatement+assertStatementWithExpression2 original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AssertStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression1"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AssertStatement"),+              Core.projectionFieldName = (Core.Name "expression1")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expression2"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the aug variant of hydra.python.syntax.Assignment+assignmentAug :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.Assignment+assignmentAug x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Assignment"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "aug"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.AssignmentExpression+assignmentExpression :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssignmentExpression+assignmentExpression name expression =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AssignmentExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))++-- | DSL accessor for the expression field of hydra.python.syntax.AssignmentExpression+assignmentExpressionExpression :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Expression+assignmentExpressionExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AssignmentExpression"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.AssignmentExpression+assignmentExpressionName :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Name+assignmentExpressionName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AssignmentExpression"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expression field of hydra.python.syntax.AssignmentExpression+assignmentExpressionWithExpression :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssignmentExpression+assignmentExpressionWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AssignmentExpression"),+      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.python.syntax.AssignmentExpression"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.AssignmentExpression+assignmentExpressionWithName :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.AssignmentExpression+assignmentExpressionWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AssignmentExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AssignmentExpression"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the typed variant of hydra.python.syntax.Assignment+assignmentTyped :: Typed.TypedTerm Syntax.TypedAssignment -> Typed.TypedTerm Syntax.Assignment+assignmentTyped x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Assignment"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typed"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the untyped variant of hydra.python.syntax.Assignment+assignmentUntyped :: Typed.TypedTerm Syntax.UntypedAssignment -> Typed.TypedTerm Syntax.Assignment+assignmentUntyped x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Assignment"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "untyped"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the dict variant of hydra.python.syntax.Atom+atomDict :: Typed.TypedTerm Syntax.Dict -> Typed.TypedTerm Syntax.Atom+atomDict x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "dict"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the dictcomp variant of hydra.python.syntax.Atom+atomDictcomp :: Typed.TypedTerm Syntax.Dictcomp -> Typed.TypedTerm Syntax.Atom+atomDictcomp x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "dictcomp"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the ellipsis variant of hydra.python.syntax.Atom+atomEllipsis :: Typed.TypedTerm Syntax.Atom+atomEllipsis =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "ellipsis"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the false variant of hydra.python.syntax.Atom+atomFalse :: Typed.TypedTerm Syntax.Atom+atomFalse =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "false"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the genexp variant of hydra.python.syntax.Atom+atomGenexp :: Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.Atom+atomGenexp x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "genexp"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the group variant of hydra.python.syntax.Atom+atomGroup :: Typed.TypedTerm Syntax.Group -> Typed.TypedTerm Syntax.Atom+atomGroup x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "group"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the list variant of hydra.python.syntax.Atom+atomList :: Typed.TypedTerm Syntax.List -> Typed.TypedTerm Syntax.Atom+atomList x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "list"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the listcomp variant of hydra.python.syntax.Atom+atomListcomp :: Typed.TypedTerm Syntax.Listcomp -> Typed.TypedTerm Syntax.Atom+atomListcomp x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "listcomp"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the name variant of hydra.python.syntax.Atom+atomName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Atom+atomName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "name"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the none variant of hydra.python.syntax.Atom+atomNone :: Typed.TypedTerm Syntax.Atom+atomNone =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "none"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the number variant of hydra.python.syntax.Atom+atomNumber :: Typed.TypedTerm Syntax.Number -> Typed.TypedTerm Syntax.Atom+atomNumber x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "number"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the set variant of hydra.python.syntax.Atom+atomSet :: Typed.TypedTerm Syntax.Set -> Typed.TypedTerm Syntax.Atom+atomSet x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "set"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the setcomp variant of hydra.python.syntax.Atom+atomSetcomp :: Typed.TypedTerm Syntax.Setcomp -> Typed.TypedTerm Syntax.Atom+atomSetcomp x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "setcomp"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the string variant of hydra.python.syntax.Atom+atomString :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm Syntax.Atom+atomString x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "string"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the true variant of hydra.python.syntax.Atom+atomTrue :: Typed.TypedTerm Syntax.Atom+atomTrue =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "true"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the tuple variant of hydra.python.syntax.Atom+atomTuple :: Typed.TypedTerm Syntax.Tuple -> Typed.TypedTerm Syntax.Atom+atomTuple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Atom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "tuple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.Attribute wrapper+attribute :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.Attribute+attribute x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Attribute"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the ampersandEqual variant of hydra.python.syntax.AugAssign+augAssignAmpersandEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignAmpersandEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "ampersandEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the atEqual variant of hydra.python.syntax.AugAssign+augAssignAtEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignAtEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "atEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the barEqual variant of hydra.python.syntax.AugAssign+augAssignBarEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignBarEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "barEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the caretEqual variant of hydra.python.syntax.AugAssign+augAssignCaretEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignCaretEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "caretEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the doubleSlashEqual variant of hydra.python.syntax.AugAssign+augAssignDoubleSlashEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignDoubleSlashEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "doubleSlashEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the leftShiftEqual variant of hydra.python.syntax.AugAssign+augAssignLeftShiftEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignLeftShiftEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "leftShiftEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the minusEqual variant of hydra.python.syntax.AugAssign+augAssignMinusEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignMinusEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "minusEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the percentEqual variant of hydra.python.syntax.AugAssign+augAssignPercentEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignPercentEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "percentEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the plusEqual variant of hydra.python.syntax.AugAssign+augAssignPlusEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignPlusEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "plusEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the rightShiftEqual variant of hydra.python.syntax.AugAssign+augAssignRightShiftEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignRightShiftEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "rightShiftEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the slashEqual variant of hydra.python.syntax.AugAssign+augAssignSlashEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignSlashEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "slashEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the starStarEqual variant of hydra.python.syntax.AugAssign+augAssignStarStarEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignStarStarEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starStarEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the timesEqual variant of hydra.python.syntax.AugAssign+augAssignTimesEqual :: Typed.TypedTerm Syntax.AugAssign+augAssignTimesEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.AugAssign"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "timesEqual"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.python.syntax.AugAssignment+augAssignment :: Typed.TypedTerm Syntax.SingleTarget -> Typed.TypedTerm Syntax.AugAssign -> Typed.TypedTerm Syntax.AnnotatedRhs -> Typed.TypedTerm Syntax.AugAssignment+augAssignment lhs augassign rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (Typed.unTypedTerm lhs)},+        Core.Field {+          Core.fieldName = (Core.Name "augassign"),+          Core.fieldTerm = (Typed.unTypedTerm augassign)},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the augassign field of hydra.python.syntax.AugAssignment+augAssignmentAugassign :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.AugAssign+augAssignmentAugassign x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+        Core.projectionFieldName = (Core.Name "augassign")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the lhs field of hydra.python.syntax.AugAssignment+augAssignmentLhs :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.SingleTarget+augAssignmentLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.AugAssignment+augAssignmentRhs :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.AnnotatedRhs+augAssignmentRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the augassign field of hydra.python.syntax.AugAssignment+augAssignmentWithAugassign :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.AugAssign -> Typed.TypedTerm Syntax.AugAssignment+augAssignmentWithAugassign original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+      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.python.syntax.AugAssignment"),+              Core.projectionFieldName = (Core.Name "lhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "augassign"),+          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.python.syntax.AugAssignment"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the lhs field of hydra.python.syntax.AugAssignment+augAssignmentWithLhs :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.SingleTarget -> Typed.TypedTerm Syntax.AugAssignment+augAssignmentWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "augassign"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+              Core.projectionFieldName = (Core.Name "augassign")})),+            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.python.syntax.AugAssignment"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.AugAssignment+augAssignmentWithRhs :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.AnnotatedRhs -> Typed.TypedTerm Syntax.AugAssignment+augAssignmentWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+      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.python.syntax.AugAssignment"),+              Core.projectionFieldName = (Core.Name "lhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "augassign"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AugAssignment"),+              Core.projectionFieldName = (Core.Name "augassign")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.AwaitPrimary+awaitPrimary :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.AwaitPrimary+awaitPrimary await primary =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AwaitPrimary"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "await"),+          Core.fieldTerm = (Typed.unTypedTerm await)},+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm primary)}]}))++-- | DSL accessor for the await field of hydra.python.syntax.AwaitPrimary+awaitPrimaryAwait :: Typed.TypedTerm Syntax.AwaitPrimary -> Typed.TypedTerm Bool+awaitPrimaryAwait x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AwaitPrimary"),+        Core.projectionFieldName = (Core.Name "await")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the primary field of hydra.python.syntax.AwaitPrimary+awaitPrimaryPrimary :: Typed.TypedTerm Syntax.AwaitPrimary -> Typed.TypedTerm Syntax.Primary+awaitPrimaryPrimary x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.AwaitPrimary"),+        Core.projectionFieldName = (Core.Name "primary")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the await field of hydra.python.syntax.AwaitPrimary+awaitPrimaryWithAwait :: Typed.TypedTerm Syntax.AwaitPrimary -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.AwaitPrimary+awaitPrimaryWithAwait original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AwaitPrimary"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "await"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AwaitPrimary"),+              Core.projectionFieldName = (Core.Name "primary")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the primary field of hydra.python.syntax.AwaitPrimary+awaitPrimaryWithPrimary :: Typed.TypedTerm Syntax.AwaitPrimary -> Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.AwaitPrimary+awaitPrimaryWithPrimary original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.AwaitPrimary"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "await"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.AwaitPrimary"),+              Core.projectionFieldName = (Core.Name "await")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.BitwiseAnd+bitwiseAnd :: Typed.TypedTerm (Maybe Syntax.BitwiseAnd) -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.BitwiseAnd+bitwiseAnd lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseAnd"),+      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.python.syntax.BitwiseAnd+bitwiseAndLhs :: Typed.TypedTerm Syntax.BitwiseAnd -> Typed.TypedTerm (Maybe Syntax.BitwiseAnd)+bitwiseAndLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.BitwiseAnd"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.BitwiseAnd+bitwiseAndRhs :: Typed.TypedTerm Syntax.BitwiseAnd -> Typed.TypedTerm Syntax.ShiftExpression+bitwiseAndRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.BitwiseAnd"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.BitwiseAnd+bitwiseAndWithLhs :: Typed.TypedTerm Syntax.BitwiseAnd -> Typed.TypedTerm (Maybe Syntax.BitwiseAnd) -> Typed.TypedTerm Syntax.BitwiseAnd+bitwiseAndWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseAnd"),+      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.python.syntax.BitwiseAnd"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.BitwiseAnd+bitwiseAndWithRhs :: Typed.TypedTerm Syntax.BitwiseAnd -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.BitwiseAnd+bitwiseAndWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseAnd"),+      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.python.syntax.BitwiseAnd"),+              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.python.syntax.BitwiseOr+bitwiseOr :: Typed.TypedTerm (Maybe Syntax.BitwiseOr) -> Typed.TypedTerm Syntax.BitwiseXor -> Typed.TypedTerm Syntax.BitwiseOr+bitwiseOr lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseOr"),+      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.python.syntax.BitwiseOr+bitwiseOrLhs :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm (Maybe Syntax.BitwiseOr)+bitwiseOrLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.BitwiseOr"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.BitwiseOr+bitwiseOrRhs :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.BitwiseXor+bitwiseOrRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.BitwiseOr"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.BitwiseOr+bitwiseOrWithLhs :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm (Maybe Syntax.BitwiseOr) -> Typed.TypedTerm Syntax.BitwiseOr+bitwiseOrWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseOr"),+      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.python.syntax.BitwiseOr"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.BitwiseOr+bitwiseOrWithRhs :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.BitwiseXor -> Typed.TypedTerm Syntax.BitwiseOr+bitwiseOrWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseOr"),+      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.python.syntax.BitwiseOr"),+              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.python.syntax.BitwiseXor+bitwiseXor :: Typed.TypedTerm (Maybe Syntax.BitwiseXor) -> Typed.TypedTerm Syntax.BitwiseAnd -> Typed.TypedTerm Syntax.BitwiseXor+bitwiseXor lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseXor"),+      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.python.syntax.BitwiseXor+bitwiseXorLhs :: Typed.TypedTerm Syntax.BitwiseXor -> Typed.TypedTerm (Maybe Syntax.BitwiseXor)+bitwiseXorLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.BitwiseXor"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.BitwiseXor+bitwiseXorRhs :: Typed.TypedTerm Syntax.BitwiseXor -> Typed.TypedTerm Syntax.BitwiseAnd+bitwiseXorRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.BitwiseXor"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.BitwiseXor+bitwiseXorWithLhs :: Typed.TypedTerm Syntax.BitwiseXor -> Typed.TypedTerm (Maybe Syntax.BitwiseXor) -> Typed.TypedTerm Syntax.BitwiseXor+bitwiseXorWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseXor"),+      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.python.syntax.BitwiseXor"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.BitwiseXor+bitwiseXorWithRhs :: Typed.TypedTerm Syntax.BitwiseXor -> Typed.TypedTerm Syntax.BitwiseAnd -> Typed.TypedTerm Syntax.BitwiseXor+bitwiseXorWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.BitwiseXor"),+      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.python.syntax.BitwiseXor"),+              Core.projectionFieldName = (Core.Name "lhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the indented variant of hydra.python.syntax.Block+blockIndented :: Typed.TypedTerm [[Syntax.Statement]] -> Typed.TypedTerm Syntax.Block+blockIndented x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Block"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "indented"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.Block+blockSimple :: Typed.TypedTerm [Syntax.SimpleStatement] -> Typed.TypedTerm Syntax.Block+blockSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Block"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.CapturePattern wrapper+capturePattern :: Typed.TypedTerm Syntax.PatternCaptureTarget -> Typed.TypedTerm Syntax.CapturePattern+capturePattern x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.CapturePattern"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.CaseBlock+caseBlock :: Typed.TypedTerm Syntax.Patterns -> Typed.TypedTerm (Maybe Syntax.Guard) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CaseBlock+caseBlock patterns guard body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Typed.unTypedTerm patterns)},+        Core.Field {+          Core.fieldName = (Core.Name "guard"),+          Core.fieldTerm = (Typed.unTypedTerm guard)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.python.syntax.CaseBlock+caseBlockBody :: Typed.TypedTerm Syntax.CaseBlock -> Typed.TypedTerm Syntax.Block+caseBlockBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the guard field of hydra.python.syntax.CaseBlock+caseBlockGuard :: Typed.TypedTerm Syntax.CaseBlock -> Typed.TypedTerm (Maybe Syntax.Guard)+caseBlockGuard x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+        Core.projectionFieldName = (Core.Name "guard")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the patterns field of hydra.python.syntax.CaseBlock+caseBlockPatterns :: Typed.TypedTerm Syntax.CaseBlock -> Typed.TypedTerm Syntax.Patterns+caseBlockPatterns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+        Core.projectionFieldName = (Core.Name "patterns")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.python.syntax.CaseBlock+caseBlockWithBody :: Typed.TypedTerm Syntax.CaseBlock -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CaseBlock+caseBlockWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+              Core.projectionFieldName = (Core.Name "patterns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "guard"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+              Core.projectionFieldName = (Core.Name "guard")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the guard field of hydra.python.syntax.CaseBlock+caseBlockWithGuard :: Typed.TypedTerm Syntax.CaseBlock -> Typed.TypedTerm (Maybe Syntax.Guard) -> Typed.TypedTerm Syntax.CaseBlock+caseBlockWithGuard original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+              Core.projectionFieldName = (Core.Name "patterns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "guard"),+          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.python.syntax.CaseBlock"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the patterns field of hydra.python.syntax.CaseBlock+caseBlockWithPatterns :: Typed.TypedTerm Syntax.CaseBlock -> Typed.TypedTerm Syntax.Patterns -> Typed.TypedTerm Syntax.CaseBlock+caseBlockWithPatterns original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "guard"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.CaseBlock"),+              Core.projectionFieldName = (Core.Name "guard")})),+            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.python.syntax.CaseBlock"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.ClassDefinition+classDefinition :: Typed.TypedTerm (Maybe Syntax.Decorators) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm (Maybe Syntax.Args) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ClassDefinition+classDefinition decorators name typeParams arguments body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          Core.fieldTerm = (Typed.unTypedTerm decorators)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Typed.unTypedTerm typeParams)},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Typed.unTypedTerm arguments)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the arguments field of hydra.python.syntax.ClassDefinition+classDefinitionArguments :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm (Maybe Syntax.Args)+classDefinitionArguments x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+        Core.projectionFieldName = (Core.Name "arguments")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body field of hydra.python.syntax.ClassDefinition+classDefinitionBody :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm Syntax.Block+classDefinitionBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the decorators field of hydra.python.syntax.ClassDefinition+classDefinitionDecorators :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm (Maybe Syntax.Decorators)+classDefinitionDecorators x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+        Core.projectionFieldName = (Core.Name "decorators")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.ClassDefinition+classDefinitionName :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm Syntax.Name+classDefinitionName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeParams field of hydra.python.syntax.ClassDefinition+classDefinitionTypeParams :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm [Syntax.TypeParameter]+classDefinitionTypeParams x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+        Core.projectionFieldName = (Core.Name "typeParams")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the arguments field of hydra.python.syntax.ClassDefinition+classDefinitionWithArguments :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm (Maybe Syntax.Args) -> Typed.TypedTerm Syntax.ClassDefinition+classDefinitionWithArguments original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "decorators")})),+            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.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the body field of hydra.python.syntax.ClassDefinition+classDefinitionWithBody :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ClassDefinition+classDefinitionWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "decorators")})),+            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.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "arguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the decorators field of hydra.python.syntax.ClassDefinition+classDefinitionWithDecorators :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm (Maybe Syntax.Decorators) -> Typed.TypedTerm Syntax.ClassDefinition+classDefinitionWithDecorators original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          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.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "arguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.python.syntax.ClassDefinition+classDefinitionWithName :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ClassDefinition+classDefinitionWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "decorators")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "arguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeParams field of hydra.python.syntax.ClassDefinition+classDefinitionWithTypeParams :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.ClassDefinition+classDefinitionWithTypeParams original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "decorators")})),+            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.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "arguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.ClassPattern+classPattern :: Typed.TypedTerm Syntax.NameOrAttribute -> Typed.TypedTerm (Maybe Syntax.PositionalPatterns) -> Typed.TypedTerm (Maybe Syntax.KeywordPatterns) -> Typed.TypedTerm Syntax.ClassPattern+classPattern nameOrAttribute positionalPatterns keywordPatterns =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nameOrAttribute"),+          Core.fieldTerm = (Typed.unTypedTerm nameOrAttribute)},+        Core.Field {+          Core.fieldName = (Core.Name "positionalPatterns"),+          Core.fieldTerm = (Typed.unTypedTerm positionalPatterns)},+        Core.Field {+          Core.fieldName = (Core.Name "keywordPatterns"),+          Core.fieldTerm = (Typed.unTypedTerm keywordPatterns)}]}))++-- | DSL accessor for the keywordPatterns field of hydra.python.syntax.ClassPattern+classPatternKeywordPatterns :: Typed.TypedTerm Syntax.ClassPattern -> Typed.TypedTerm (Maybe Syntax.KeywordPatterns)+classPatternKeywordPatterns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+        Core.projectionFieldName = (Core.Name "keywordPatterns")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the nameOrAttribute field of hydra.python.syntax.ClassPattern+classPatternNameOrAttribute :: Typed.TypedTerm Syntax.ClassPattern -> Typed.TypedTerm Syntax.NameOrAttribute+classPatternNameOrAttribute x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+        Core.projectionFieldName = (Core.Name "nameOrAttribute")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the positionalPatterns field of hydra.python.syntax.ClassPattern+classPatternPositionalPatterns :: Typed.TypedTerm Syntax.ClassPattern -> Typed.TypedTerm (Maybe Syntax.PositionalPatterns)+classPatternPositionalPatterns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+        Core.projectionFieldName = (Core.Name "positionalPatterns")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the keywordPatterns field of hydra.python.syntax.ClassPattern+classPatternWithKeywordPatterns :: Typed.TypedTerm Syntax.ClassPattern -> Typed.TypedTerm (Maybe Syntax.KeywordPatterns) -> Typed.TypedTerm Syntax.ClassPattern+classPatternWithKeywordPatterns original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nameOrAttribute"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+              Core.projectionFieldName = (Core.Name "nameOrAttribute")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "positionalPatterns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+              Core.projectionFieldName = (Core.Name "positionalPatterns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keywordPatterns"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the nameOrAttribute field of hydra.python.syntax.ClassPattern+classPatternWithNameOrAttribute :: Typed.TypedTerm Syntax.ClassPattern -> Typed.TypedTerm Syntax.NameOrAttribute -> Typed.TypedTerm Syntax.ClassPattern+classPatternWithNameOrAttribute original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nameOrAttribute"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "positionalPatterns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+              Core.projectionFieldName = (Core.Name "positionalPatterns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keywordPatterns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+              Core.projectionFieldName = (Core.Name "keywordPatterns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the positionalPatterns field of hydra.python.syntax.ClassPattern+classPatternWithPositionalPatterns :: Typed.TypedTerm Syntax.ClassPattern -> Typed.TypedTerm (Maybe Syntax.PositionalPatterns) -> Typed.TypedTerm Syntax.ClassPattern+classPatternWithPositionalPatterns original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nameOrAttribute"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+              Core.projectionFieldName = (Core.Name "nameOrAttribute")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "positionalPatterns"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "keywordPatterns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ClassPattern"),+              Core.projectionFieldName = (Core.Name "keywordPatterns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the capture variant of hydra.python.syntax.ClosedPattern+closedPatternCapture :: Typed.TypedTerm Syntax.CapturePattern -> Typed.TypedTerm Syntax.ClosedPattern+closedPatternCapture x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ClosedPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "capture"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the class variant of hydra.python.syntax.ClosedPattern+closedPatternClass :: Typed.TypedTerm Syntax.ClassPattern -> Typed.TypedTerm Syntax.ClosedPattern+closedPatternClass x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ClosedPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "class"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the group variant of hydra.python.syntax.ClosedPattern+closedPatternGroup :: Typed.TypedTerm Syntax.GroupPattern -> Typed.TypedTerm Syntax.ClosedPattern+closedPatternGroup x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ClosedPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "group"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the literal variant of hydra.python.syntax.ClosedPattern+closedPatternLiteral :: Typed.TypedTerm Syntax.LiteralExpression -> Typed.TypedTerm Syntax.ClosedPattern+closedPatternLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ClosedPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the mapping variant of hydra.python.syntax.ClosedPattern+closedPatternMapping :: Typed.TypedTerm Syntax.MappingPattern -> Typed.TypedTerm Syntax.ClosedPattern+closedPatternMapping x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ClosedPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapping"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the sequence variant of hydra.python.syntax.ClosedPattern+closedPatternSequence :: Typed.TypedTerm Syntax.SequencePattern -> Typed.TypedTerm Syntax.ClosedPattern+closedPatternSequence x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ClosedPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "sequence"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the value variant of hydra.python.syntax.ClosedPattern+closedPatternValue :: Typed.TypedTerm Syntax.ValuePattern -> Typed.TypedTerm Syntax.ClosedPattern+closedPatternValue x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ClosedPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "value"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the wildcard variant of hydra.python.syntax.ClosedPattern+closedPatternWildcard :: Typed.TypedTerm Syntax.ClosedPattern+closedPatternWildcard =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ClosedPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wildcard"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.python.syntax.CommaStarEtc+commaStarEtc :: Typed.TypedTerm [Syntax.ParamMaybeDefault] -> Typed.TypedTerm (Maybe Syntax.Keywords) -> Typed.TypedTerm Syntax.CommaStarEtc+commaStarEtc paramMaybeDefault keywords =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CommaStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramMaybeDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Typed.unTypedTerm keywords)}]}))++-- | DSL accessor for the keywords field of hydra.python.syntax.CommaStarEtc+commaStarEtcKeywords :: Typed.TypedTerm Syntax.CommaStarEtc -> Typed.TypedTerm (Maybe Syntax.Keywords)+commaStarEtcKeywords x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.CommaStarEtc"),+        Core.projectionFieldName = (Core.Name "keywords")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramMaybeDefault field of hydra.python.syntax.CommaStarEtc+commaStarEtcParamMaybeDefault :: Typed.TypedTerm Syntax.CommaStarEtc -> Typed.TypedTerm [Syntax.ParamMaybeDefault]+commaStarEtcParamMaybeDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.CommaStarEtc"),+        Core.projectionFieldName = (Core.Name "paramMaybeDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the keywords field of hydra.python.syntax.CommaStarEtc+commaStarEtcWithKeywords :: Typed.TypedTerm Syntax.CommaStarEtc -> Typed.TypedTerm (Maybe Syntax.Keywords) -> Typed.TypedTerm Syntax.CommaStarEtc+commaStarEtcWithKeywords original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CommaStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.CommaStarEtc"),+              Core.projectionFieldName = (Core.Name "paramMaybeDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the paramMaybeDefault field of hydra.python.syntax.CommaStarEtc+commaStarEtcWithParamMaybeDefault :: Typed.TypedTerm Syntax.CommaStarEtc -> Typed.TypedTerm [Syntax.ParamMaybeDefault] -> Typed.TypedTerm Syntax.CommaStarEtc+commaStarEtcWithParamMaybeDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CommaStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.CommaStarEtc"),+              Core.projectionFieldName = (Core.Name "keywords")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPair :: Typed.TypedTerm Syntax.CompareOp -> Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPair operator rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CompareOpBitwiseOrPair"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Typed.unTypedTerm operator)},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the operator field of hydra.python.syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPairOperator :: Typed.TypedTerm Syntax.CompareOpBitwiseOrPair -> Typed.TypedTerm Syntax.CompareOp+compareOpBitwiseOrPairOperator x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.CompareOpBitwiseOrPair"),+        Core.projectionFieldName = (Core.Name "operator")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPairRhs :: Typed.TypedTerm Syntax.CompareOpBitwiseOrPair -> Typed.TypedTerm Syntax.BitwiseOr+compareOpBitwiseOrPairRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.CompareOpBitwiseOrPair"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the operator field of hydra.python.syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPairWithOperator :: Typed.TypedTerm Syntax.CompareOpBitwiseOrPair -> Typed.TypedTerm Syntax.CompareOp -> Typed.TypedTerm Syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPairWithOperator original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CompareOpBitwiseOrPair"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          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.python.syntax.CompareOpBitwiseOrPair"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPairWithRhs :: Typed.TypedTerm Syntax.CompareOpBitwiseOrPair -> Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPairWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.CompareOpBitwiseOrPair"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.CompareOpBitwiseOrPair"),+              Core.projectionFieldName = (Core.Name "operator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the eq variant of hydra.python.syntax.CompareOp+compareOpEq :: Typed.TypedTerm Syntax.CompareOp+compareOpEq =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "eq"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the gt variant of hydra.python.syntax.CompareOp+compareOpGt :: Typed.TypedTerm Syntax.CompareOp+compareOpGt =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "gt"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the gte variant of hydra.python.syntax.CompareOp+compareOpGte :: Typed.TypedTerm Syntax.CompareOp+compareOpGte =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "gte"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the in variant of hydra.python.syntax.CompareOp+compareOpIn :: Typed.TypedTerm Syntax.CompareOp+compareOpIn =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "in"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the is variant of hydra.python.syntax.CompareOp+compareOpIs :: Typed.TypedTerm Syntax.CompareOp+compareOpIs =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "is"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the isnot variant of hydra.python.syntax.CompareOp+compareOpIsnot :: Typed.TypedTerm Syntax.CompareOp+compareOpIsnot =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "isnot"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the lt variant of hydra.python.syntax.CompareOp+compareOpLt :: Typed.TypedTerm Syntax.CompareOp+compareOpLt =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lt"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the lte variant of hydra.python.syntax.CompareOp+compareOpLte :: Typed.TypedTerm Syntax.CompareOp+compareOpLte =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lte"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the noteq variant of hydra.python.syntax.CompareOp+compareOpNoteq :: Typed.TypedTerm Syntax.CompareOp+compareOpNoteq =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "noteq"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the notin variant of hydra.python.syntax.CompareOp+compareOpNotin :: Typed.TypedTerm Syntax.CompareOp+compareOpNotin =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompareOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "notin"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.python.syntax.Comparison+comparison :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm [Syntax.CompareOpBitwiseOrPair] -> Typed.TypedTerm Syntax.Comparison+comparison lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Comparison"),+      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.python.syntax.Comparison+comparisonLhs :: Typed.TypedTerm Syntax.Comparison -> Typed.TypedTerm Syntax.BitwiseOr+comparisonLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Comparison"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.Comparison+comparisonRhs :: Typed.TypedTerm Syntax.Comparison -> Typed.TypedTerm [Syntax.CompareOpBitwiseOrPair]+comparisonRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Comparison"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.Comparison+comparisonWithLhs :: Typed.TypedTerm Syntax.Comparison -> Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.Comparison+comparisonWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Comparison"),+      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.python.syntax.Comparison"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.Comparison+comparisonWithRhs :: Typed.TypedTerm Syntax.Comparison -> Typed.TypedTerm [Syntax.CompareOpBitwiseOrPair] -> Typed.TypedTerm Syntax.Comparison+comparisonWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Comparison"),+      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.python.syntax.Comparison"),+              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.python.syntax.ComplexNumber+complexNumber :: Typed.TypedTerm Syntax.SignedRealNumber -> Typed.TypedTerm Syntax.PlusOrMinus -> Typed.TypedTerm Syntax.ImaginaryNumber -> Typed.TypedTerm Syntax.ComplexNumber+complexNumber real plusOrMinus imaginary =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "real"),+          Core.fieldTerm = (Typed.unTypedTerm real)},+        Core.Field {+          Core.fieldName = (Core.Name "plusOrMinus"),+          Core.fieldTerm = (Typed.unTypedTerm plusOrMinus)},+        Core.Field {+          Core.fieldName = (Core.Name "imaginary"),+          Core.fieldTerm = (Typed.unTypedTerm imaginary)}]}))++-- | DSL accessor for the imaginary field of hydra.python.syntax.ComplexNumber+complexNumberImaginary :: Typed.TypedTerm Syntax.ComplexNumber -> Typed.TypedTerm Syntax.ImaginaryNumber+complexNumberImaginary x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+        Core.projectionFieldName = (Core.Name "imaginary")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the plusOrMinus field of hydra.python.syntax.ComplexNumber+complexNumberPlusOrMinus :: Typed.TypedTerm Syntax.ComplexNumber -> Typed.TypedTerm Syntax.PlusOrMinus+complexNumberPlusOrMinus x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+        Core.projectionFieldName = (Core.Name "plusOrMinus")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the real field of hydra.python.syntax.ComplexNumber+complexNumberReal :: Typed.TypedTerm Syntax.ComplexNumber -> Typed.TypedTerm Syntax.SignedRealNumber+complexNumberReal x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+        Core.projectionFieldName = (Core.Name "real")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the imaginary field of hydra.python.syntax.ComplexNumber+complexNumberWithImaginary :: Typed.TypedTerm Syntax.ComplexNumber -> Typed.TypedTerm Syntax.ImaginaryNumber -> Typed.TypedTerm Syntax.ComplexNumber+complexNumberWithImaginary original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "real"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+              Core.projectionFieldName = (Core.Name "real")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "plusOrMinus"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+              Core.projectionFieldName = (Core.Name "plusOrMinus")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "imaginary"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the plusOrMinus field of hydra.python.syntax.ComplexNumber+complexNumberWithPlusOrMinus :: Typed.TypedTerm Syntax.ComplexNumber -> Typed.TypedTerm Syntax.PlusOrMinus -> Typed.TypedTerm Syntax.ComplexNumber+complexNumberWithPlusOrMinus original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "real"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+              Core.projectionFieldName = (Core.Name "real")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "plusOrMinus"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "imaginary"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+              Core.projectionFieldName = (Core.Name "imaginary")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the real field of hydra.python.syntax.ComplexNumber+complexNumberWithReal :: Typed.TypedTerm Syntax.ComplexNumber -> Typed.TypedTerm Syntax.SignedRealNumber -> Typed.TypedTerm Syntax.ComplexNumber+complexNumberWithReal original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "real"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "plusOrMinus"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+              Core.projectionFieldName = (Core.Name "plusOrMinus")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "imaginary"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ComplexNumber"),+              Core.projectionFieldName = (Core.Name "imaginary")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the classDef variant of hydra.python.syntax.CompoundStatement+compoundStatementClassDef :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm Syntax.CompoundStatement+compoundStatementClassDef x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompoundStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "classDef"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the for variant of hydra.python.syntax.CompoundStatement+compoundStatementFor :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.CompoundStatement+compoundStatementFor x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompoundStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "for"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the function variant of hydra.python.syntax.CompoundStatement+compoundStatementFunction :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.CompoundStatement+compoundStatementFunction x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompoundStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "function"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the if variant of hydra.python.syntax.CompoundStatement+compoundStatementIf :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.CompoundStatement+compoundStatementIf x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompoundStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "if"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the match variant of hydra.python.syntax.CompoundStatement+compoundStatementMatch :: Typed.TypedTerm Syntax.MatchStatement -> Typed.TypedTerm Syntax.CompoundStatement+compoundStatementMatch x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompoundStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "match"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the try variant of hydra.python.syntax.CompoundStatement+compoundStatementTry :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.CompoundStatement+compoundStatementTry x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompoundStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "try"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the while variant of hydra.python.syntax.CompoundStatement+compoundStatementWhile :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.CompoundStatement+compoundStatementWhile x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompoundStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "while"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the with variant of hydra.python.syntax.CompoundStatement+compoundStatementWith :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm Syntax.CompoundStatement+compoundStatementWith x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.CompoundStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "with"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.Conditional+conditional :: Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Conditional+conditional body if_ else_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Conditional"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "if"),+          Core.fieldTerm = (Typed.unTypedTerm if_)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm else_)}]}))++-- | DSL accessor for the body field of hydra.python.syntax.Conditional+conditionalBody :: Typed.TypedTerm Syntax.Conditional -> Typed.TypedTerm Syntax.Disjunction+conditionalBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Conditional"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the else field of hydra.python.syntax.Conditional+conditionalElse :: Typed.TypedTerm Syntax.Conditional -> Typed.TypedTerm Syntax.Expression+conditionalElse x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Conditional"),+        Core.projectionFieldName = (Core.Name "else")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the if field of hydra.python.syntax.Conditional+conditionalIf :: Typed.TypedTerm Syntax.Conditional -> Typed.TypedTerm Syntax.Disjunction+conditionalIf x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Conditional"),+        Core.projectionFieldName = (Core.Name "if")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.python.syntax.Conditional+conditionalWithBody :: Typed.TypedTerm Syntax.Conditional -> Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm Syntax.Conditional+conditionalWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Conditional"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "if"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Conditional"),+              Core.projectionFieldName = (Core.Name "if")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Conditional"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the else field of hydra.python.syntax.Conditional+conditionalWithElse :: Typed.TypedTerm Syntax.Conditional -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Conditional+conditionalWithElse original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Conditional"),+      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.python.syntax.Conditional"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "if"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Conditional"),+              Core.projectionFieldName = (Core.Name "if")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the if field of hydra.python.syntax.Conditional+conditionalWithIf :: Typed.TypedTerm Syntax.Conditional -> Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm Syntax.Conditional+conditionalWithIf original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Conditional"),+      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.python.syntax.Conditional"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "if"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Conditional"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.Conjunction wrapper+conjunction :: Typed.TypedTerm [Syntax.Inversion] -> Typed.TypedTerm Syntax.Conjunction+conjunction x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Conjunction"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.Decorators wrapper+decorators :: Typed.TypedTerm [Syntax.NamedExpression] -> Typed.TypedTerm Syntax.Decorators+decorators x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Decorators"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.Default wrapper+default_ :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Default+default_ x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Default"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.DelStatement wrapper+delStatement :: Typed.TypedTerm Syntax.DelTargets -> Typed.TypedTerm Syntax.DelStatement+delStatement x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.DelStatement"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the name variant of hydra.python.syntax.DelTAtom+delTAtomName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.DelTAtom+delTAtomName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.DelTAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "name"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the target variant of hydra.python.syntax.DelTAtom+delTAtomTarget :: Typed.TypedTerm Syntax.DelTarget -> Typed.TypedTerm Syntax.DelTAtom+delTAtomTarget x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.DelTAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "target"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the targets variant of hydra.python.syntax.DelTAtom+delTAtomTargets :: Typed.TypedTerm Syntax.DelTargets -> Typed.TypedTerm Syntax.DelTAtom+delTAtomTargets x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.DelTAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "targets"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the delTAtom variant of hydra.python.syntax.DelTarget+delTargetDelTAtom :: Typed.TypedTerm Syntax.DelTAtom -> Typed.TypedTerm Syntax.DelTarget+delTargetDelTAtom x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.DelTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "delTAtom"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the primaryAndName variant of hydra.python.syntax.DelTarget+delTargetPrimaryAndName :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.DelTarget+delTargetPrimaryAndName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.DelTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primaryAndName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the primaryAndSlices variant of hydra.python.syntax.DelTarget+delTargetPrimaryAndSlices :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.DelTarget+delTargetPrimaryAndSlices x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.DelTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primaryAndSlices"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.DelTargets wrapper+delTargets :: Typed.TypedTerm [Syntax.DelTarget] -> Typed.TypedTerm Syntax.DelTargets+delTargets x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.DelTargets"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.Dict wrapper+dict :: Typed.TypedTerm [Syntax.DoubleStarredKvpair] -> Typed.TypedTerm Syntax.Dict+dict x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Dict"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.Dictcomp+dictcomp :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Dictcomp+dictcomp kvpair forIfClauses =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Dictcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "kvpair"),+          Core.fieldTerm = (Typed.unTypedTerm kvpair)},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Typed.unTypedTerm forIfClauses)}]}))++-- | DSL accessor for the forIfClauses field of hydra.python.syntax.Dictcomp+dictcompForIfClauses :: Typed.TypedTerm Syntax.Dictcomp -> Typed.TypedTerm Syntax.ForIfClauses+dictcompForIfClauses x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Dictcomp"),+        Core.projectionFieldName = (Core.Name "forIfClauses")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the kvpair field of hydra.python.syntax.Dictcomp+dictcompKvpair :: Typed.TypedTerm Syntax.Dictcomp -> Typed.TypedTerm Syntax.Kvpair+dictcompKvpair x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Dictcomp"),+        Core.projectionFieldName = (Core.Name "kvpair")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the forIfClauses field of hydra.python.syntax.Dictcomp+dictcompWithForIfClauses :: Typed.TypedTerm Syntax.Dictcomp -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Dictcomp+dictcompWithForIfClauses original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Dictcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "kvpair"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Dictcomp"),+              Core.projectionFieldName = (Core.Name "kvpair")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the kvpair field of hydra.python.syntax.Dictcomp+dictcompWithKvpair :: Typed.TypedTerm Syntax.Dictcomp -> Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.Dictcomp+dictcompWithKvpair original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Dictcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "kvpair"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Dictcomp"),+              Core.projectionFieldName = (Core.Name "forIfClauses")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.Disjunction wrapper+disjunction :: Typed.TypedTerm [Syntax.Conjunction] -> Typed.TypedTerm Syntax.Disjunction+disjunction x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Disjunction"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.DottedAsName+dottedAsName :: Typed.TypedTerm Syntax.DottedName -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.DottedAsName+dottedAsName name as =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.DottedAsName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm as)}]}))++-- | DSL accessor for the as field of hydra.python.syntax.DottedAsName+dottedAsNameAs :: Typed.TypedTerm Syntax.DottedAsName -> Typed.TypedTerm (Maybe Syntax.Name)+dottedAsNameAs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.DottedAsName"),+        Core.projectionFieldName = (Core.Name "as")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.DottedAsName+dottedAsNameName :: Typed.TypedTerm Syntax.DottedAsName -> Typed.TypedTerm Syntax.DottedName+dottedAsNameName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.DottedAsName"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the as field of hydra.python.syntax.DottedAsName+dottedAsNameWithAs :: Typed.TypedTerm Syntax.DottedAsName -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.DottedAsName+dottedAsNameWithAs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.DottedAsName"),+      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.python.syntax.DottedAsName"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.DottedAsName+dottedAsNameWithName :: Typed.TypedTerm Syntax.DottedAsName -> Typed.TypedTerm Syntax.DottedName -> Typed.TypedTerm Syntax.DottedAsName+dottedAsNameWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.DottedAsName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.DottedAsName"),+              Core.projectionFieldName = (Core.Name "as")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.DottedName wrapper+dottedName :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.DottedName+dottedName x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.DottedName"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.DoubleStarPattern wrapper+doubleStarPattern :: Typed.TypedTerm Syntax.PatternCaptureTarget -> Typed.TypedTerm Syntax.DoubleStarPattern+doubleStarPattern x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.DoubleStarPattern"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.DoubleStarTypeParameter+doubleStarTypeParameter :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.DoubleStarTypeParameter+doubleStarTypeParameter name default_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.DoubleStarTypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))++-- | DSL accessor for the default field of hydra.python.syntax.DoubleStarTypeParameter+doubleStarTypeParameterDefault :: Typed.TypedTerm Syntax.DoubleStarTypeParameter -> Typed.TypedTerm (Maybe Syntax.Expression)+doubleStarTypeParameterDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.DoubleStarTypeParameter"),+        Core.projectionFieldName = (Core.Name "default")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.DoubleStarTypeParameter+doubleStarTypeParameterName :: Typed.TypedTerm Syntax.DoubleStarTypeParameter -> Typed.TypedTerm Syntax.Name+doubleStarTypeParameterName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.DoubleStarTypeParameter"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the default field of hydra.python.syntax.DoubleStarTypeParameter+doubleStarTypeParameterWithDefault :: Typed.TypedTerm Syntax.DoubleStarTypeParameter -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.DoubleStarTypeParameter+doubleStarTypeParameterWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.DoubleStarTypeParameter"),+      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.python.syntax.DoubleStarTypeParameter"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.DoubleStarTypeParameter+doubleStarTypeParameterWithName :: Typed.TypedTerm Syntax.DoubleStarTypeParameter -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.DoubleStarTypeParameter+doubleStarTypeParameterWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.DoubleStarTypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          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.python.syntax.DoubleStarTypeParameter"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the pair variant of hydra.python.syntax.DoubleStarredKvpair+doubleStarredKvpairPair :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.DoubleStarredKvpair+doubleStarredKvpairPair x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.DoubleStarredKvpair"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pair"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starred variant of hydra.python.syntax.DoubleStarredKvpair+doubleStarredKvpairStarred :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.DoubleStarredKvpair+doubleStarredKvpairStarred x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.DoubleStarredKvpair"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starred"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.Eval wrapper+eval :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Eval+eval x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Eval"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.ExceptBlock+exceptBlock :: Typed.TypedTerm (Maybe Syntax.ExceptExpression) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ExceptBlock+exceptBlock expression body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.python.syntax.ExceptBlock+exceptBlockBody :: Typed.TypedTerm Syntax.ExceptBlock -> Typed.TypedTerm Syntax.Block+exceptBlockBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptBlock"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expression field of hydra.python.syntax.ExceptBlock+exceptBlockExpression :: Typed.TypedTerm Syntax.ExceptBlock -> Typed.TypedTerm (Maybe Syntax.ExceptExpression)+exceptBlockExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptBlock"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.python.syntax.ExceptBlock+exceptBlockWithBody :: Typed.TypedTerm Syntax.ExceptBlock -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ExceptBlock+exceptBlockWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptBlock"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the expression field of hydra.python.syntax.ExceptBlock+exceptBlockWithExpression :: Typed.TypedTerm Syntax.ExceptBlock -> Typed.TypedTerm (Maybe Syntax.ExceptExpression) -> Typed.TypedTerm Syntax.ExceptBlock+exceptBlockWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          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.python.syntax.ExceptBlock"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.ExceptExpression+exceptExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.ExceptExpression+exceptExpression expression as =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm as)}]}))++-- | DSL accessor for the as field of hydra.python.syntax.ExceptExpression+exceptExpressionAs :: Typed.TypedTerm Syntax.ExceptExpression -> Typed.TypedTerm (Maybe Syntax.Name)+exceptExpressionAs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptExpression"),+        Core.projectionFieldName = (Core.Name "as")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expression field of hydra.python.syntax.ExceptExpression+exceptExpressionExpression :: Typed.TypedTerm Syntax.ExceptExpression -> Typed.TypedTerm Syntax.Expression+exceptExpressionExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptExpression"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the as field of hydra.python.syntax.ExceptExpression+exceptExpressionWithAs :: Typed.TypedTerm Syntax.ExceptExpression -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.ExceptExpression+exceptExpressionWithAs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptExpression"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the expression field of hydra.python.syntax.ExceptExpression+exceptExpressionWithExpression :: Typed.TypedTerm Syntax.ExceptExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ExceptExpression+exceptExpressionWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptExpression"),+              Core.projectionFieldName = (Core.Name "as")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.ExceptStarBlock+exceptStarBlock :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ExceptStarBlock+exceptStarBlock expression as body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm as)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the as field of hydra.python.syntax.ExceptStarBlock+exceptStarBlockAs :: Typed.TypedTerm Syntax.ExceptStarBlock -> Typed.TypedTerm (Maybe Syntax.Name)+exceptStarBlockAs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+        Core.projectionFieldName = (Core.Name "as")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body field of hydra.python.syntax.ExceptStarBlock+exceptStarBlockBody :: Typed.TypedTerm Syntax.ExceptStarBlock -> Typed.TypedTerm Syntax.Block+exceptStarBlockBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expression field of hydra.python.syntax.ExceptStarBlock+exceptStarBlockExpression :: Typed.TypedTerm Syntax.ExceptStarBlock -> Typed.TypedTerm Syntax.Expression+exceptStarBlockExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the as field of hydra.python.syntax.ExceptStarBlock+exceptStarBlockWithAs :: Typed.TypedTerm Syntax.ExceptStarBlock -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.ExceptStarBlock+exceptStarBlockWithAs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          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.python.syntax.ExceptStarBlock"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the body field of hydra.python.syntax.ExceptStarBlock+exceptStarBlockWithBody :: Typed.TypedTerm Syntax.ExceptStarBlock -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ExceptStarBlock+exceptStarBlockWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+              Core.projectionFieldName = (Core.Name "as")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the expression field of hydra.python.syntax.ExceptStarBlock+exceptStarBlockWithExpression :: Typed.TypedTerm Syntax.ExceptStarBlock -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ExceptStarBlock+exceptStarBlockWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ExceptStarBlock"),+              Core.projectionFieldName = (Core.Name "as")})),+            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.python.syntax.ExceptStarBlock"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the conditional variant of hydra.python.syntax.Expression+expressionConditional :: Typed.TypedTerm Syntax.Conditional -> Typed.TypedTerm Syntax.Expression+expressionConditional x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Expression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "conditional"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the lambda variant of hydra.python.syntax.Expression+expressionLambda :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm Syntax.Expression+expressionLambda x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Expression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lambda"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.Expression+expressionSimple :: Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm Syntax.Expression+expressionSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Expression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the complement variant of hydra.python.syntax.Factor+factorComplement :: Typed.TypedTerm Syntax.Factor -> Typed.TypedTerm Syntax.Factor+factorComplement x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Factor"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "complement"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the negative variant of hydra.python.syntax.Factor+factorNegative :: Typed.TypedTerm Syntax.Factor -> Typed.TypedTerm Syntax.Factor+factorNegative x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Factor"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "negative"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the positive variant of hydra.python.syntax.Factor+factorPositive :: Typed.TypedTerm Syntax.Factor -> Typed.TypedTerm Syntax.Factor+factorPositive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Factor"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "positive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.Factor+factorSimple :: Typed.TypedTerm Syntax.Power -> Typed.TypedTerm Syntax.Factor+factorSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Factor"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.File wrapper+file :: Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.File+file x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.File"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.ForIfClause+forIfClause :: Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm [Syntax.Disjunction] -> Typed.TypedTerm Syntax.ForIfClause+forIfClause async targets in_ ifs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Typed.unTypedTerm async)},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Typed.unTypedTerm targets)},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Typed.unTypedTerm in_)},+        Core.Field {+          Core.fieldName = (Core.Name "ifs"),+          Core.fieldTerm = (Typed.unTypedTerm ifs)}]}))++-- | DSL accessor for the async field of hydra.python.syntax.ForIfClause+forIfClauseAsync :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm Bool+forIfClauseAsync x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+        Core.projectionFieldName = (Core.Name "async")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the ifs field of hydra.python.syntax.ForIfClause+forIfClauseIfs :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm [Syntax.Disjunction]+forIfClauseIfs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+        Core.projectionFieldName = (Core.Name "ifs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the in field of hydra.python.syntax.ForIfClause+forIfClauseIn :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm Syntax.Disjunction+forIfClauseIn x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+        Core.projectionFieldName = (Core.Name "in")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the targets field of hydra.python.syntax.ForIfClause+forIfClauseTargets :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm [Syntax.StarTarget]+forIfClauseTargets x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+        Core.projectionFieldName = (Core.Name "targets")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the async field of hydra.python.syntax.ForIfClause+forIfClauseWithAsync :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ForIfClause+forIfClauseWithAsync original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "in")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "ifs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "ifs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the ifs field of hydra.python.syntax.ForIfClause+forIfClauseWithIfs :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm [Syntax.Disjunction] -> Typed.TypedTerm Syntax.ForIfClause+forIfClauseWithIfs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "in")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "ifs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the in field of hydra.python.syntax.ForIfClause+forIfClauseWithIn :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm Syntax.ForIfClause+forIfClauseWithIn original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "ifs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "ifs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the targets field of hydra.python.syntax.ForIfClause+forIfClauseWithTargets :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.ForIfClause+forIfClauseWithTargets original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "in")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "ifs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForIfClause"),+              Core.projectionFieldName = (Core.Name "ifs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.ForIfClauses wrapper+forIfClauses :: Typed.TypedTerm [Syntax.ForIfClause] -> Typed.TypedTerm Syntax.ForIfClauses+forIfClauses x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ForIfClauses"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.ForStatement+forStatement :: Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.ForStatement+forStatement async targets expressions typeComment body else_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Typed.unTypedTerm async)},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Typed.unTypedTerm targets)},+        Core.Field {+          Core.fieldName = (Core.Name "expressions"),+          Core.fieldTerm = (Typed.unTypedTerm expressions)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm typeComment)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm else_)}]}))++-- | DSL accessor for the async field of hydra.python.syntax.ForStatement+forStatementAsync :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Bool+forStatementAsync x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+        Core.projectionFieldName = (Core.Name "async")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body field of hydra.python.syntax.ForStatement+forStatementBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Block+forStatementBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the else field of hydra.python.syntax.ForStatement+forStatementElse :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.Block)+forStatementElse x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+        Core.projectionFieldName = (Core.Name "else")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expressions field of hydra.python.syntax.ForStatement+forStatementExpressions :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm [Syntax.StarExpression]+forStatementExpressions x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+        Core.projectionFieldName = (Core.Name "expressions")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the targets field of hydra.python.syntax.ForStatement+forStatementTargets :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm [Syntax.StarTarget]+forStatementTargets x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+        Core.projectionFieldName = (Core.Name "targets")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeComment field of hydra.python.syntax.ForStatement+forStatementTypeComment :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.TypeComment)+forStatementTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+        Core.projectionFieldName = (Core.Name "typeComment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the async field of hydra.python.syntax.ForStatement+forStatementWithAsync :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ForStatement+forStatementWithAsync original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expressions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "expressions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            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.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the body field of hydra.python.syntax.ForStatement+forStatementWithBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ForStatement+forStatementWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expressions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "expressions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the else field of hydra.python.syntax.ForStatement+forStatementWithElse :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.ForStatement+forStatementWithElse original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expressions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "expressions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            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.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the expressions field of hydra.python.syntax.ForStatement+forStatementWithExpressions :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm Syntax.ForStatement+forStatementWithExpressions original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expressions"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            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.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the targets field of hydra.python.syntax.ForStatement+forStatementWithTargets :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.ForStatement+forStatementWithTargets original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "expressions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "expressions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            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.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeComment field of hydra.python.syntax.ForStatement+forStatementWithTypeComment :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ForStatement+forStatementWithTypeComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expressions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "expressions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          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.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ForStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.FuncTypeComment wrapper+funcTypeComment :: Typed.TypedTerm Syntax.TypeComment -> Typed.TypedTerm Syntax.FuncTypeComment+funcTypeComment x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.FuncTypeComment"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.FunctionDefRaw+functionDefRaw :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm (Maybe Syntax.Parameters) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe Syntax.FuncTypeComment) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefRaw async name typeParams params returnType funcTypeComment block =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Typed.unTypedTerm async)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Typed.unTypedTerm typeParams)},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Typed.unTypedTerm params)},+        Core.Field {+          Core.fieldName = (Core.Name "returnType"),+          Core.fieldTerm = (Typed.unTypedTerm returnType)},+        Core.Field {+          Core.fieldName = (Core.Name "funcTypeComment"),+          Core.fieldTerm = (Typed.unTypedTerm funcTypeComment)},+        Core.Field {+          Core.fieldName = (Core.Name "block"),+          Core.fieldTerm = (Typed.unTypedTerm block)}]}))++-- | DSL accessor for the async field of hydra.python.syntax.FunctionDefRaw+functionDefRawAsync :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Bool+functionDefRawAsync x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+        Core.projectionFieldName = (Core.Name "async")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the block field of hydra.python.syntax.FunctionDefRaw+functionDefRawBlock :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Syntax.Block+functionDefRawBlock x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+        Core.projectionFieldName = (Core.Name "block")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the funcTypeComment field of hydra.python.syntax.FunctionDefRaw+functionDefRawFuncTypeComment :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm (Maybe Syntax.FuncTypeComment)+functionDefRawFuncTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+        Core.projectionFieldName = (Core.Name "funcTypeComment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.FunctionDefRaw+functionDefRawName :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Syntax.Name+functionDefRawName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the params field of hydra.python.syntax.FunctionDefRaw+functionDefRawParams :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm (Maybe Syntax.Parameters)+functionDefRawParams x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+        Core.projectionFieldName = (Core.Name "params")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the returnType field of hydra.python.syntax.FunctionDefRaw+functionDefRawReturnType :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm (Maybe Syntax.Expression)+functionDefRawReturnType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+        Core.projectionFieldName = (Core.Name "returnType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeParams field of hydra.python.syntax.FunctionDefRaw+functionDefRawTypeParams :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm [Syntax.TypeParameter]+functionDefRawTypeParams x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+        Core.projectionFieldName = (Core.Name "typeParams")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the async field of hydra.python.syntax.FunctionDefRaw+functionDefRawWithAsync :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefRawWithAsync original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          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.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "returnType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "returnType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "funcTypeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "funcTypeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "block"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "block")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the block field of hydra.python.syntax.FunctionDefRaw+functionDefRawWithBlock :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefRawWithBlock original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "async")})),+            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.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "returnType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "returnType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "funcTypeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "funcTypeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "block"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the funcTypeComment field of hydra.python.syntax.FunctionDefRaw+functionDefRawWithFuncTypeComment :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm (Maybe Syntax.FuncTypeComment) -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefRawWithFuncTypeComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "async")})),+            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.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "returnType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "returnType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "funcTypeComment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "block"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "block")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.python.syntax.FunctionDefRaw+functionDefRawWithName :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefRawWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "returnType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "returnType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "funcTypeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "funcTypeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "block"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "block")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the params field of hydra.python.syntax.FunctionDefRaw+functionDefRawWithParams :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm (Maybe Syntax.Parameters) -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefRawWithParams original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "async")})),+            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.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "returnType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "returnType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "funcTypeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "funcTypeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "block"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "block")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the returnType field of hydra.python.syntax.FunctionDefRaw+functionDefRawWithReturnType :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefRawWithReturnType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "async")})),+            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.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "returnType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "funcTypeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "funcTypeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "block"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "block")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeParams field of hydra.python.syntax.FunctionDefRaw+functionDefRawWithTypeParams :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefRawWithTypeParams original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "async")})),+            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.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "returnType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "returnType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "funcTypeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "funcTypeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "block"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefRaw"),+              Core.projectionFieldName = (Core.Name "block")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.FunctionDefinition+functionDefinition :: Typed.TypedTerm (Maybe Syntax.Decorators) -> Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Syntax.FunctionDefinition+functionDefinition decorators raw =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          Core.fieldTerm = (Typed.unTypedTerm decorators)},+        Core.Field {+          Core.fieldName = (Core.Name "raw"),+          Core.fieldTerm = (Typed.unTypedTerm raw)}]}))++-- | DSL accessor for the decorators field of hydra.python.syntax.FunctionDefinition+functionDefinitionDecorators :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm (Maybe Syntax.Decorators)+functionDefinitionDecorators x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefinition"),+        Core.projectionFieldName = (Core.Name "decorators")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the raw field of hydra.python.syntax.FunctionDefinition+functionDefinitionRaw :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.FunctionDefRaw+functionDefinitionRaw x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefinition"),+        Core.projectionFieldName = (Core.Name "raw")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the decorators field of hydra.python.syntax.FunctionDefinition+functionDefinitionWithDecorators :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm (Maybe Syntax.Decorators) -> Typed.TypedTerm Syntax.FunctionDefinition+functionDefinitionWithDecorators original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "raw"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefinition"),+              Core.projectionFieldName = (Core.Name "raw")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the raw field of hydra.python.syntax.FunctionDefinition+functionDefinitionWithRaw :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Syntax.FunctionDefinition+functionDefinitionWithRaw original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.FunctionDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "decorators"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.FunctionDefinition"),+              Core.projectionFieldName = (Core.Name "decorators")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "raw"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.Genexp+genexp :: Typed.TypedTerm Syntax.GenexpHead -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Genexp+genexp head tail =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Genexp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Typed.unTypedTerm head)},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Typed.unTypedTerm tail)}]}))++-- | DSL accessor for the head field of hydra.python.syntax.Genexp+genexpHead :: Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.GenexpHead+genexpHead x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Genexp"),+        Core.projectionFieldName = (Core.Name "head")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL injection for the assignment variant of hydra.python.syntax.GenexpHead+genexpHeadAssignment :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.GenexpHead+genexpHeadAssignment x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.GenexpHead"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "assignment"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the expression variant of hydra.python.syntax.GenexpHead+genexpHeadExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.GenexpHead+genexpHeadExpression x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.GenexpHead"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "expression"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL accessor for the tail field of hydra.python.syntax.Genexp+genexpTail :: Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.ForIfClauses+genexpTail x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Genexp"),+        Core.projectionFieldName = (Core.Name "tail")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the head field of hydra.python.syntax.Genexp+genexpWithHead :: Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.GenexpHead -> Typed.TypedTerm Syntax.Genexp+genexpWithHead original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Genexp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Genexp"),+              Core.projectionFieldName = (Core.Name "tail")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tail field of hydra.python.syntax.Genexp+genexpWithTail :: Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Genexp+genexpWithTail original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Genexp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Genexp"),+              Core.projectionFieldName = (Core.Name "head")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the expression variant of hydra.python.syntax.Group+groupExpression :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Group+groupExpression x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Group"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "expression"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.GroupPattern wrapper+groupPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.GroupPattern+groupPattern x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.GroupPattern"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the yield variant of hydra.python.syntax.Group+groupYield :: Typed.TypedTerm Syntax.YieldExpression -> Typed.TypedTerm Syntax.Group+groupYield x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Group"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "yield"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.Guard wrapper+guard :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Guard+guard x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Guard"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.IfStatement+ifStatement :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.IfTail) -> Typed.TypedTerm Syntax.IfStatement+ifStatement condition body continuation =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "condition"),+          Core.fieldTerm = (Typed.unTypedTerm condition)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "continuation"),+          Core.fieldTerm = (Typed.unTypedTerm continuation)}]}))++-- | DSL accessor for the body field of hydra.python.syntax.IfStatement+ifStatementBody :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.Block+ifStatementBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the condition field of hydra.python.syntax.IfStatement+ifStatementCondition :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.NamedExpression+ifStatementCondition x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+        Core.projectionFieldName = (Core.Name "condition")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the continuation field of hydra.python.syntax.IfStatement+ifStatementContinuation :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm (Maybe Syntax.IfTail)+ifStatementContinuation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+        Core.projectionFieldName = (Core.Name "continuation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.python.syntax.IfStatement+ifStatementWithBody :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.IfStatement+ifStatementWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "condition"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+              Core.projectionFieldName = (Core.Name "condition")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "continuation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+              Core.projectionFieldName = (Core.Name "continuation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the condition field of hydra.python.syntax.IfStatement+ifStatementWithCondition :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.IfStatement+ifStatementWithCondition original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "condition"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "continuation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+              Core.projectionFieldName = (Core.Name "continuation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the continuation field of hydra.python.syntax.IfStatement+ifStatementWithContinuation :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm (Maybe Syntax.IfTail) -> Typed.TypedTerm Syntax.IfStatement+ifStatementWithContinuation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "condition"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.IfStatement"),+              Core.projectionFieldName = (Core.Name "condition")})),+            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.python.syntax.IfStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "continuation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the elif variant of hydra.python.syntax.IfTail+ifTailElif :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.IfTail+ifTailElif x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.IfTail"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "elif"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the else variant of hydra.python.syntax.IfTail+ifTailElse :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.IfTail+ifTailElse x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.IfTail"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "else"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.ImaginaryNumber wrapper+imaginaryNumber :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.ImaginaryNumber+imaginaryNumber x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ImaginaryNumber"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.ImportFrom+importFrom :: Typed.TypedTerm [Syntax.RelativeImportPrefix] -> Typed.TypedTerm (Maybe Syntax.DottedName) -> Typed.TypedTerm Syntax.ImportFromTargets -> Typed.TypedTerm Syntax.ImportFrom+importFrom prefixes dottedName targets =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "prefixes"),+          Core.fieldTerm = (Typed.unTypedTerm prefixes)},+        Core.Field {+          Core.fieldName = (Core.Name "dottedName"),+          Core.fieldTerm = (Typed.unTypedTerm dottedName)},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Typed.unTypedTerm targets)}]}))++-- | DSL constructor for hydra.python.syntax.ImportFromAsName+importFromAsName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.ImportFromAsName+importFromAsName name as =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ImportFromAsName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm as)}]}))++-- | DSL accessor for the as field of hydra.python.syntax.ImportFromAsName+importFromAsNameAs :: Typed.TypedTerm Syntax.ImportFromAsName -> Typed.TypedTerm (Maybe Syntax.Name)+importFromAsNameAs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFromAsName"),+        Core.projectionFieldName = (Core.Name "as")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.ImportFromAsName+importFromAsNameName :: Typed.TypedTerm Syntax.ImportFromAsName -> Typed.TypedTerm Syntax.Name+importFromAsNameName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFromAsName"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the as field of hydra.python.syntax.ImportFromAsName+importFromAsNameWithAs :: Typed.TypedTerm Syntax.ImportFromAsName -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.ImportFromAsName+importFromAsNameWithAs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ImportFromAsName"),+      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.python.syntax.ImportFromAsName"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.ImportFromAsName+importFromAsNameWithName :: Typed.TypedTerm Syntax.ImportFromAsName -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ImportFromAsName+importFromAsNameWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ImportFromAsName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFromAsName"),+              Core.projectionFieldName = (Core.Name "as")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL accessor for the dottedName field of hydra.python.syntax.ImportFrom+importFromDottedName :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm (Maybe Syntax.DottedName)+importFromDottedName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+        Core.projectionFieldName = (Core.Name "dottedName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the prefixes field of hydra.python.syntax.ImportFrom+importFromPrefixes :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm [Syntax.RelativeImportPrefix]+importFromPrefixes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+        Core.projectionFieldName = (Core.Name "prefixes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the targets field of hydra.python.syntax.ImportFrom+importFromTargets :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm Syntax.ImportFromTargets+importFromTargets x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+        Core.projectionFieldName = (Core.Name "targets")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL injection for the parens variant of hydra.python.syntax.ImportFromTargets+importFromTargetsParens :: Typed.TypedTerm [Syntax.ImportFromAsName] -> Typed.TypedTerm Syntax.ImportFromTargets+importFromTargetsParens x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ImportFromTargets"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "parens"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.ImportFromTargets+importFromTargetsSimple :: Typed.TypedTerm [Syntax.ImportFromAsName] -> Typed.TypedTerm Syntax.ImportFromTargets+importFromTargetsSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ImportFromTargets"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the star variant of hydra.python.syntax.ImportFromTargets+importFromTargetsStar :: Typed.TypedTerm Syntax.ImportFromTargets+importFromTargetsStar =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ImportFromTargets"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "star"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL updater for the dottedName field of hydra.python.syntax.ImportFrom+importFromWithDottedName :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm (Maybe Syntax.DottedName) -> Typed.TypedTerm Syntax.ImportFrom+importFromWithDottedName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "prefixes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+              Core.projectionFieldName = (Core.Name "prefixes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dottedName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the prefixes field of hydra.python.syntax.ImportFrom+importFromWithPrefixes :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm [Syntax.RelativeImportPrefix] -> Typed.TypedTerm Syntax.ImportFrom+importFromWithPrefixes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "prefixes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "dottedName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+              Core.projectionFieldName = (Core.Name "dottedName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the targets field of hydra.python.syntax.ImportFrom+importFromWithTargets :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm Syntax.ImportFromTargets -> Typed.TypedTerm Syntax.ImportFrom+importFromWithTargets original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "prefixes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+              Core.projectionFieldName = (Core.Name "prefixes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dottedName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ImportFrom"),+              Core.projectionFieldName = (Core.Name "dottedName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.python.syntax.ImportName wrapper+importName :: Typed.TypedTerm [Syntax.DottedAsName] -> Typed.TypedTerm Syntax.ImportName+importName x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ImportName"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the from variant of hydra.python.syntax.ImportStatement+importStatementFrom :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm Syntax.ImportStatement+importStatementFrom x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ImportStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "from"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the name variant of hydra.python.syntax.ImportStatement+importStatementName :: Typed.TypedTerm Syntax.ImportName -> Typed.TypedTerm Syntax.ImportStatement+importStatementName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ImportStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "name"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.Interactive wrapper+interactive :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.Interactive+interactive x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Interactive"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the not variant of hydra.python.syntax.Inversion+inversionNot :: Typed.TypedTerm Syntax.Inversion -> Typed.TypedTerm Syntax.Inversion+inversionNot x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Inversion"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "not"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.Inversion+inversionSimple :: Typed.TypedTerm Syntax.Comparison -> Typed.TypedTerm Syntax.Inversion+inversionSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Inversion"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.ItemsPattern wrapper+itemsPattern :: Typed.TypedTerm [Syntax.KeyValuePattern] -> Typed.TypedTerm Syntax.ItemsPattern+itemsPattern x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ItemsPattern"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.KeyValuePattern+keyValuePattern :: Typed.TypedTerm Syntax.LiteralExpressionOrAttribute -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.KeyValuePattern+keyValuePattern key value =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.KeyValuePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "key"),+          Core.fieldTerm = (Typed.unTypedTerm key)},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))++-- | DSL accessor for the key field of hydra.python.syntax.KeyValuePattern+keyValuePatternKey :: Typed.TypedTerm Syntax.KeyValuePattern -> Typed.TypedTerm Syntax.LiteralExpressionOrAttribute+keyValuePatternKey x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.KeyValuePattern"),+        Core.projectionFieldName = (Core.Name "key")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the value field of hydra.python.syntax.KeyValuePattern+keyValuePatternValue :: Typed.TypedTerm Syntax.KeyValuePattern -> Typed.TypedTerm Syntax.Pattern+keyValuePatternValue x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.KeyValuePattern"),+        Core.projectionFieldName = (Core.Name "value")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the key field of hydra.python.syntax.KeyValuePattern+keyValuePatternWithKey :: Typed.TypedTerm Syntax.KeyValuePattern -> Typed.TypedTerm Syntax.LiteralExpressionOrAttribute -> Typed.TypedTerm Syntax.KeyValuePattern+keyValuePatternWithKey original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.KeyValuePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "key"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.KeyValuePattern"),+              Core.projectionFieldName = (Core.Name "value")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the value field of hydra.python.syntax.KeyValuePattern+keyValuePatternWithValue :: Typed.TypedTerm Syntax.KeyValuePattern -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.KeyValuePattern+keyValuePatternWithValue original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.KeyValuePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "key"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.KeyValuePattern"),+              Core.projectionFieldName = (Core.Name "key")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.KeywordPattern+keywordPattern :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.KeywordPattern+keywordPattern name pattern =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.KeywordPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "pattern"),+          Core.fieldTerm = (Typed.unTypedTerm pattern)}]}))++-- | DSL accessor for the name field of hydra.python.syntax.KeywordPattern+keywordPatternName :: Typed.TypedTerm Syntax.KeywordPattern -> Typed.TypedTerm Syntax.Name+keywordPatternName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.KeywordPattern"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the pattern field of hydra.python.syntax.KeywordPattern+keywordPatternPattern :: Typed.TypedTerm Syntax.KeywordPattern -> Typed.TypedTerm Syntax.Pattern+keywordPatternPattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.KeywordPattern"),+        Core.projectionFieldName = (Core.Name "pattern")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.python.syntax.KeywordPattern+keywordPatternWithName :: Typed.TypedTerm Syntax.KeywordPattern -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.KeywordPattern+keywordPatternWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.KeywordPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "pattern"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.KeywordPattern"),+              Core.projectionFieldName = (Core.Name "pattern")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the pattern field of hydra.python.syntax.KeywordPattern+keywordPatternWithPattern :: Typed.TypedTerm Syntax.KeywordPattern -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.KeywordPattern+keywordPatternWithPattern original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.KeywordPattern"),+      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.python.syntax.KeywordPattern"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "pattern"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.python.syntax.KeywordPatterns wrapper+keywordPatterns :: Typed.TypedTerm [Syntax.KeywordPattern] -> Typed.TypedTerm Syntax.KeywordPatterns+keywordPatterns x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.KeywordPatterns"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.Keywords wrapper+keywords :: Typed.TypedTerm Syntax.ParamNoDefault -> Typed.TypedTerm Syntax.Keywords+keywords x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Keywords"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.Kvpair+kvpair :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Kvpair+kvpair key value =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Kvpair"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "key"),+          Core.fieldTerm = (Typed.unTypedTerm key)},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))++-- | DSL accessor for the key field of hydra.python.syntax.Kvpair+kvpairKey :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.Expression+kvpairKey x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Kvpair"),+        Core.projectionFieldName = (Core.Name "key")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the value field of hydra.python.syntax.Kvpair+kvpairValue :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.Expression+kvpairValue x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Kvpair"),+        Core.projectionFieldName = (Core.Name "value")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the key field of hydra.python.syntax.Kvpair+kvpairWithKey :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Kvpair+kvpairWithKey original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Kvpair"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "key"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Kvpair"),+              Core.projectionFieldName = (Core.Name "value")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the value field of hydra.python.syntax.Kvpair+kvpairWithValue :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Kvpair+kvpairWithValue original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Kvpair"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "key"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Kvpair"),+              Core.projectionFieldName = (Core.Name "key")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.Kwarg+kwarg :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Kwarg+kwarg name value =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Kwarg"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))++-- | DSL accessor for the name field of hydra.python.syntax.Kwarg+kwargName :: Typed.TypedTerm Syntax.Kwarg -> Typed.TypedTerm Syntax.Name+kwargName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Kwarg"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL injection for the doubleStarred variant of hydra.python.syntax.KwargOrDoubleStarred+kwargOrDoubleStarredDoubleStarred :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.KwargOrDoubleStarred+kwargOrDoubleStarredDoubleStarred x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.KwargOrDoubleStarred"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "doubleStarred"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the kwarg variant of hydra.python.syntax.KwargOrDoubleStarred+kwargOrDoubleStarredKwarg :: Typed.TypedTerm Syntax.Kwarg -> Typed.TypedTerm Syntax.KwargOrDoubleStarred+kwargOrDoubleStarredKwarg x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.KwargOrDoubleStarred"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "kwarg"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the kwarg variant of hydra.python.syntax.KwargOrStarred+kwargOrStarredKwarg :: Typed.TypedTerm Syntax.Kwarg -> Typed.TypedTerm Syntax.KwargOrStarred+kwargOrStarredKwarg x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.KwargOrStarred"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "kwarg"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starred variant of hydra.python.syntax.KwargOrStarred+kwargOrStarredStarred :: Typed.TypedTerm Syntax.StarredExpression -> Typed.TypedTerm Syntax.KwargOrStarred+kwargOrStarredStarred x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.KwargOrStarred"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starred"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL accessor for the value field of hydra.python.syntax.Kwarg+kwargValue :: Typed.TypedTerm Syntax.Kwarg -> Typed.TypedTerm Syntax.Expression+kwargValue x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Kwarg"),+        Core.projectionFieldName = (Core.Name "value")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.python.syntax.Kwarg+kwargWithName :: Typed.TypedTerm Syntax.Kwarg -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Kwarg+kwargWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Kwarg"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Kwarg"),+              Core.projectionFieldName = (Core.Name "value")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the value field of hydra.python.syntax.Kwarg+kwargWithValue :: Typed.TypedTerm Syntax.Kwarg -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Kwarg+kwargWithValue original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Kwarg"),+      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.python.syntax.Kwarg"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.Lambda+lambda :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Lambda+lambda params body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Lambda"),+      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.python.syntax.Lambda+lambdaBody :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm Syntax.Expression+lambdaBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Lambda"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.LambdaKwds wrapper+lambdaKwds :: Typed.TypedTerm Syntax.LambdaParamNoDefault -> Typed.TypedTerm Syntax.LambdaKwds+lambdaKwds x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.LambdaKwds"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefault :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Default) -> Typed.TypedTerm Syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefault param default_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParamMaybeDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Typed.unTypedTerm param)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))++-- | DSL accessor for the default field of hydra.python.syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefaultDefault :: Typed.TypedTerm Syntax.LambdaParamMaybeDefault -> Typed.TypedTerm (Maybe Syntax.Default)+lambdaParamMaybeDefaultDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParamMaybeDefault"),+        Core.projectionFieldName = (Core.Name "default")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the param field of hydra.python.syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefaultParam :: Typed.TypedTerm Syntax.LambdaParamMaybeDefault -> Typed.TypedTerm Syntax.Name+lambdaParamMaybeDefaultParam x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParamMaybeDefault"),+        Core.projectionFieldName = (Core.Name "param")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the default field of hydra.python.syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefaultWithDefault :: Typed.TypedTerm Syntax.LambdaParamMaybeDefault -> Typed.TypedTerm (Maybe Syntax.Default) -> Typed.TypedTerm Syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefaultWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParamMaybeDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParamMaybeDefault"),+              Core.projectionFieldName = (Core.Name "param")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the param field of hydra.python.syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefaultWithParam :: Typed.TypedTerm Syntax.LambdaParamMaybeDefault -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefaultWithParam original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParamMaybeDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          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.python.syntax.LambdaParamMaybeDefault"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.LambdaParamNoDefault wrapper+lambdaParamNoDefault :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.LambdaParamNoDefault+lambdaParamNoDefault x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.LambdaParamNoDefault"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.LambdaParamWithDefault+lambdaParamWithDefault :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Default) -> Typed.TypedTerm Syntax.LambdaParamWithDefault+lambdaParamWithDefault param default_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParamWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Typed.unTypedTerm param)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))++-- | DSL accessor for the default field of hydra.python.syntax.LambdaParamWithDefault+lambdaParamWithDefaultDefault :: Typed.TypedTerm Syntax.LambdaParamWithDefault -> Typed.TypedTerm (Maybe Syntax.Default)+lambdaParamWithDefaultDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParamWithDefault"),+        Core.projectionFieldName = (Core.Name "default")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the param field of hydra.python.syntax.LambdaParamWithDefault+lambdaParamWithDefaultParam :: Typed.TypedTerm Syntax.LambdaParamWithDefault -> Typed.TypedTerm Syntax.Name+lambdaParamWithDefaultParam x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParamWithDefault"),+        Core.projectionFieldName = (Core.Name "param")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the default field of hydra.python.syntax.LambdaParamWithDefault+lambdaParamWithDefaultWithDefault :: Typed.TypedTerm Syntax.LambdaParamWithDefault -> Typed.TypedTerm (Maybe Syntax.Default) -> Typed.TypedTerm Syntax.LambdaParamWithDefault+lambdaParamWithDefaultWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParamWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParamWithDefault"),+              Core.projectionFieldName = (Core.Name "param")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the param field of hydra.python.syntax.LambdaParamWithDefault+lambdaParamWithDefaultWithParam :: Typed.TypedTerm Syntax.LambdaParamWithDefault -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.LambdaParamWithDefault+lambdaParamWithDefaultWithParam original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParamWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          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.python.syntax.LambdaParamWithDefault"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.LambdaParameters+lambdaParameters :: Typed.TypedTerm (Maybe Syntax.LambdaSlashNoDefault) -> Typed.TypedTerm [Syntax.LambdaParamNoDefault] -> Typed.TypedTerm [Syntax.LambdaParamWithDefault] -> Typed.TypedTerm (Maybe Syntax.LambdaStarEtc) -> Typed.TypedTerm Syntax.LambdaParameters+lambdaParameters slashNoDefault paramNoDefault paramWithDefault starEtc =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slashNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm slashNoDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramNoDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramWithDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm starEtc)}]}))++-- | DSL accessor for the paramNoDefault field of hydra.python.syntax.LambdaParameters+lambdaParametersParamNoDefault :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm [Syntax.LambdaParamNoDefault]+lambdaParametersParamNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+        Core.projectionFieldName = (Core.Name "paramNoDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramWithDefault field of hydra.python.syntax.LambdaParameters+lambdaParametersParamWithDefault :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm [Syntax.LambdaParamWithDefault]+lambdaParametersParamWithDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+        Core.projectionFieldName = (Core.Name "paramWithDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the slashNoDefault field of hydra.python.syntax.LambdaParameters+lambdaParametersSlashNoDefault :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm (Maybe Syntax.LambdaSlashNoDefault)+lambdaParametersSlashNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+        Core.projectionFieldName = (Core.Name "slashNoDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the starEtc field of hydra.python.syntax.LambdaParameters+lambdaParametersStarEtc :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm (Maybe Syntax.LambdaStarEtc)+lambdaParametersStarEtc x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+        Core.projectionFieldName = (Core.Name "starEtc")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the paramNoDefault field of hydra.python.syntax.LambdaParameters+lambdaParametersWithParamNoDefault :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm [Syntax.LambdaParamNoDefault] -> Typed.TypedTerm Syntax.LambdaParameters+lambdaParametersWithParamNoDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slashNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "slashNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramWithDefault field of hydra.python.syntax.LambdaParameters+lambdaParametersWithParamWithDefault :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm [Syntax.LambdaParamWithDefault] -> Typed.TypedTerm Syntax.LambdaParameters+lambdaParametersWithParamWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slashNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "slashNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the slashNoDefault field of hydra.python.syntax.LambdaParameters+lambdaParametersWithSlashNoDefault :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm (Maybe Syntax.LambdaSlashNoDefault) -> Typed.TypedTerm Syntax.LambdaParameters+lambdaParametersWithSlashNoDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slashNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the starEtc field of hydra.python.syntax.LambdaParameters+lambdaParametersWithStarEtc :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm (Maybe Syntax.LambdaStarEtc) -> Typed.TypedTerm Syntax.LambdaParameters+lambdaParametersWithStarEtc original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slashNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "slashNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the params field of hydra.python.syntax.Lambda+lambdaParams :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm Syntax.LambdaParameters+lambdaParams x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Lambda"),+        Core.projectionFieldName = (Core.Name "params")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.LambdaSlashNoDefault+lambdaSlashNoDefault :: Typed.TypedTerm [Syntax.LambdaParamNoDefault] -> Typed.TypedTerm Syntax.LambdaSlashNoDefault+lambdaSlashNoDefault parameters =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaSlashNoDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameters"),+          Core.fieldTerm = (Typed.unTypedTerm parameters)}]}))++-- | DSL accessor for the parameters field of hydra.python.syntax.LambdaSlashNoDefault+lambdaSlashNoDefaultParameters :: Typed.TypedTerm Syntax.LambdaSlashNoDefault -> Typed.TypedTerm [Syntax.LambdaParamNoDefault]+lambdaSlashNoDefaultParameters x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaSlashNoDefault"),+        Core.projectionFieldName = (Core.Name "parameters")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the parameters field of hydra.python.syntax.LambdaSlashNoDefault+lambdaSlashNoDefaultWithParameters :: Typed.TypedTerm Syntax.LambdaSlashNoDefault -> Typed.TypedTerm [Syntax.LambdaParamNoDefault] -> Typed.TypedTerm Syntax.LambdaSlashNoDefault+lambdaSlashNoDefaultWithParameters original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaSlashNoDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameters"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.LambdaSlashWithDefault+lambdaSlashWithDefault :: Typed.TypedTerm [Syntax.LambdaParamNoDefault] -> Typed.TypedTerm [Syntax.LambdaParamWithDefault] -> Typed.TypedTerm Syntax.LambdaSlashWithDefault+lambdaSlashWithDefault paramNoDefault paramWithDefault =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaSlashWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramNoDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramWithDefault)}]}))++-- | DSL accessor for the paramNoDefault field of hydra.python.syntax.LambdaSlashWithDefault+lambdaSlashWithDefaultParamNoDefault :: Typed.TypedTerm Syntax.LambdaSlashWithDefault -> Typed.TypedTerm [Syntax.LambdaParamNoDefault]+lambdaSlashWithDefaultParamNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaSlashWithDefault"),+        Core.projectionFieldName = (Core.Name "paramNoDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramWithDefault field of hydra.python.syntax.LambdaSlashWithDefault+lambdaSlashWithDefaultParamWithDefault :: Typed.TypedTerm Syntax.LambdaSlashWithDefault -> Typed.TypedTerm [Syntax.LambdaParamWithDefault]+lambdaSlashWithDefaultParamWithDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaSlashWithDefault"),+        Core.projectionFieldName = (Core.Name "paramWithDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the paramNoDefault field of hydra.python.syntax.LambdaSlashWithDefault+lambdaSlashWithDefaultWithParamNoDefault :: Typed.TypedTerm Syntax.LambdaSlashWithDefault -> Typed.TypedTerm [Syntax.LambdaParamNoDefault] -> Typed.TypedTerm Syntax.LambdaSlashWithDefault+lambdaSlashWithDefaultWithParamNoDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaSlashWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaSlashWithDefault"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramWithDefault field of hydra.python.syntax.LambdaSlashWithDefault+lambdaSlashWithDefaultWithParamWithDefault :: Typed.TypedTerm Syntax.LambdaSlashWithDefault -> Typed.TypedTerm [Syntax.LambdaParamWithDefault] -> Typed.TypedTerm Syntax.LambdaSlashWithDefault+lambdaSlashWithDefaultWithParamWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.LambdaSlashWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.LambdaSlashWithDefault"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the kwds variant of hydra.python.syntax.LambdaStarEtc+lambdaStarEtcKwds :: Typed.TypedTerm Syntax.LambdaKwds -> Typed.TypedTerm Syntax.LambdaStarEtc+lambdaStarEtcKwds x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LambdaStarEtc"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "kwds"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the paramMaybeDefault variant of hydra.python.syntax.LambdaStarEtc+lambdaStarEtcParamMaybeDefault :: Typed.TypedTerm [Syntax.LambdaParamMaybeDefault] -> Typed.TypedTerm Syntax.LambdaStarEtc+lambdaStarEtcParamMaybeDefault x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LambdaStarEtc"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "paramMaybeDefault"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the paramNoDefault variant of hydra.python.syntax.LambdaStarEtc+lambdaStarEtcParamNoDefault :: Typed.TypedTerm Syntax.LambdaParamNoDefault -> Typed.TypedTerm Syntax.LambdaStarEtc+lambdaStarEtcParamNoDefault x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LambdaStarEtc"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "paramNoDefault"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the star variant of hydra.python.syntax.LambdaStarEtc+lambdaStarEtcStar :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.LambdaStarEtc+lambdaStarEtcStar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LambdaStarEtc"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "star"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL updater for the body field of hydra.python.syntax.Lambda+lambdaWithBody :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Lambda+lambdaWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Lambda"),+      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.python.syntax.Lambda"),+              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.python.syntax.Lambda+lambdaWithParams :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm Syntax.Lambda+lambdaWithParams original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Lambda"),+      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.python.syntax.Lambda"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.List wrapper+list :: Typed.TypedTerm [Syntax.StarNamedExpression] -> Typed.TypedTerm Syntax.List+list x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.List"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.Listcomp+listcomp :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Listcomp+listcomp expression forIfClauses =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Listcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Typed.unTypedTerm forIfClauses)}]}))++-- | DSL accessor for the expression field of hydra.python.syntax.Listcomp+listcompExpression :: Typed.TypedTerm Syntax.Listcomp -> Typed.TypedTerm Syntax.NamedExpression+listcompExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Listcomp"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the forIfClauses field of hydra.python.syntax.Listcomp+listcompForIfClauses :: Typed.TypedTerm Syntax.Listcomp -> Typed.TypedTerm Syntax.ForIfClauses+listcompForIfClauses x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Listcomp"),+        Core.projectionFieldName = (Core.Name "forIfClauses")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expression field of hydra.python.syntax.Listcomp+listcompWithExpression :: Typed.TypedTerm Syntax.Listcomp -> Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Listcomp+listcompWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Listcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Listcomp"),+              Core.projectionFieldName = (Core.Name "forIfClauses")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the forIfClauses field of hydra.python.syntax.Listcomp+listcompWithForIfClauses :: Typed.TypedTerm Syntax.Listcomp -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Listcomp+listcompWithForIfClauses original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Listcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Listcomp"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the complex variant of hydra.python.syntax.LiteralExpression+literalExpressionComplex :: Typed.TypedTerm Syntax.ComplexNumber -> Typed.TypedTerm Syntax.LiteralExpression+literalExpressionComplex x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LiteralExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "complex"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the false variant of hydra.python.syntax.LiteralExpression+literalExpressionFalse :: Typed.TypedTerm Syntax.LiteralExpression+literalExpressionFalse =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LiteralExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "false"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the none variant of hydra.python.syntax.LiteralExpression+literalExpressionNone :: Typed.TypedTerm Syntax.LiteralExpression+literalExpressionNone =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LiteralExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "none"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the number variant of hydra.python.syntax.LiteralExpression+literalExpressionNumber :: Typed.TypedTerm Syntax.SignedNumber -> Typed.TypedTerm Syntax.LiteralExpression+literalExpressionNumber x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LiteralExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "number"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the attribute variant of hydra.python.syntax.LiteralExpressionOrAttribute+literalExpressionOrAttributeAttribute :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm Syntax.LiteralExpressionOrAttribute+literalExpressionOrAttributeAttribute x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LiteralExpressionOrAttribute"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "attribute"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the literal variant of hydra.python.syntax.LiteralExpressionOrAttribute+literalExpressionOrAttributeLiteral :: Typed.TypedTerm Syntax.LiteralExpression -> Typed.TypedTerm Syntax.LiteralExpressionOrAttribute+literalExpressionOrAttributeLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LiteralExpressionOrAttribute"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the string variant of hydra.python.syntax.LiteralExpression+literalExpressionString :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm Syntax.LiteralExpression+literalExpressionString x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LiteralExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "string"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the true variant of hydra.python.syntax.LiteralExpression+literalExpressionTrue :: Typed.TypedTerm Syntax.LiteralExpression+literalExpressionTrue =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.LiteralExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "true"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.python.syntax.MappingPattern+mappingPattern :: Typed.TypedTerm (Maybe Syntax.ItemsPattern) -> Typed.TypedTerm (Maybe Syntax.DoubleStarPattern) -> Typed.TypedTerm Syntax.MappingPattern+mappingPattern items doubleStar =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.MappingPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Typed.unTypedTerm items)},+        Core.Field {+          Core.fieldName = (Core.Name "doubleStar"),+          Core.fieldTerm = (Typed.unTypedTerm doubleStar)}]}))++-- | DSL accessor for the doubleStar field of hydra.python.syntax.MappingPattern+mappingPatternDoubleStar :: Typed.TypedTerm Syntax.MappingPattern -> Typed.TypedTerm (Maybe Syntax.DoubleStarPattern)+mappingPatternDoubleStar x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.MappingPattern"),+        Core.projectionFieldName = (Core.Name "doubleStar")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the items field of hydra.python.syntax.MappingPattern+mappingPatternItems :: Typed.TypedTerm Syntax.MappingPattern -> Typed.TypedTerm (Maybe Syntax.ItemsPattern)+mappingPatternItems x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.MappingPattern"),+        Core.projectionFieldName = (Core.Name "items")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the doubleStar field of hydra.python.syntax.MappingPattern+mappingPatternWithDoubleStar :: Typed.TypedTerm Syntax.MappingPattern -> Typed.TypedTerm (Maybe Syntax.DoubleStarPattern) -> Typed.TypedTerm Syntax.MappingPattern+mappingPatternWithDoubleStar original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.MappingPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.MappingPattern"),+              Core.projectionFieldName = (Core.Name "items")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "doubleStar"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the items field of hydra.python.syntax.MappingPattern+mappingPatternWithItems :: Typed.TypedTerm Syntax.MappingPattern -> Typed.TypedTerm (Maybe Syntax.ItemsPattern) -> Typed.TypedTerm Syntax.MappingPattern+mappingPatternWithItems original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.MappingPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "doubleStar"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.MappingPattern"),+              Core.projectionFieldName = (Core.Name "doubleStar")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.MatchStatement+matchStatement :: Typed.TypedTerm Syntax.SubjectExpression -> Typed.TypedTerm [Syntax.CaseBlock] -> Typed.TypedTerm Syntax.MatchStatement+matchStatement subject cases =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.MatchStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm subject)},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))++-- | DSL accessor for the cases field of hydra.python.syntax.MatchStatement+matchStatementCases :: Typed.TypedTerm Syntax.MatchStatement -> Typed.TypedTerm [Syntax.CaseBlock]+matchStatementCases x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.MatchStatement"),+        Core.projectionFieldName = (Core.Name "cases")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the subject field of hydra.python.syntax.MatchStatement+matchStatementSubject :: Typed.TypedTerm Syntax.MatchStatement -> Typed.TypedTerm Syntax.SubjectExpression+matchStatementSubject x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.MatchStatement"),+        Core.projectionFieldName = (Core.Name "subject")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the cases field of hydra.python.syntax.MatchStatement+matchStatementWithCases :: Typed.TypedTerm Syntax.MatchStatement -> Typed.TypedTerm [Syntax.CaseBlock] -> Typed.TypedTerm Syntax.MatchStatement+matchStatementWithCases original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.MatchStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.MatchStatement"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the subject field of hydra.python.syntax.MatchStatement+matchStatementWithSubject :: Typed.TypedTerm Syntax.MatchStatement -> Typed.TypedTerm Syntax.SubjectExpression -> Typed.TypedTerm Syntax.MatchStatement+matchStatementWithSubject original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.MatchStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          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.python.syntax.MatchStatement"),+              Core.projectionFieldName = (Core.Name "cases")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.MaybeSequencePattern wrapper+maybeSequencePattern :: Typed.TypedTerm [Syntax.MaybeStarPattern] -> Typed.TypedTerm Syntax.MaybeSequencePattern+maybeSequencePattern x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.MaybeSequencePattern"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the pattern variant of hydra.python.syntax.MaybeStarPattern+maybeStarPatternPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.MaybeStarPattern+maybeStarPatternPattern x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.MaybeStarPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pattern"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the star variant of hydra.python.syntax.MaybeStarPattern+maybeStarPatternStar :: Typed.TypedTerm Syntax.StarPattern -> Typed.TypedTerm Syntax.MaybeStarPattern+maybeStarPatternStar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.MaybeStarPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "star"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.Module wrapper+module_ :: Typed.TypedTerm [[Syntax.Statement]] -> Typed.TypedTerm Syntax.Module+module_ x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Module"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.Name wrapper+name :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Name+name x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Name"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.NameOrAttribute wrapper+nameOrAttribute :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.NameOrAttribute+nameOrAttribute x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.NameOrAttribute"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the assignment variant of hydra.python.syntax.NamedExpression+namedExpressionAssignment :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.NamedExpression+namedExpressionAssignment x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.NamedExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "assignment"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.NamedExpression+namedExpressionSimple :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.NamedExpression+namedExpressionSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.NamedExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtc :: Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation -> Typed.TypedTerm [Syntax.ParamMaybeDefault] -> Typed.TypedTerm (Maybe Syntax.Keywords) -> Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtc paramNoDefaultStarAnnotation paramMaybeDefault keywords =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefaultStarAnnotation"),+          Core.fieldTerm = (Typed.unTypedTerm paramNoDefaultStarAnnotation)},+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramMaybeDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Typed.unTypedTerm keywords)}]}))++-- | DSL accessor for the keywords field of hydra.python.syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcKeywords :: Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc -> Typed.TypedTerm (Maybe Syntax.Keywords)+noDefaultStarAnnotationStarEtcKeywords x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+        Core.projectionFieldName = (Core.Name "keywords")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramMaybeDefault field of hydra.python.syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcParamMaybeDefault :: Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc -> Typed.TypedTerm [Syntax.ParamMaybeDefault]+noDefaultStarAnnotationStarEtcParamMaybeDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+        Core.projectionFieldName = (Core.Name "paramMaybeDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramNoDefaultStarAnnotation field of hydra.python.syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcParamNoDefaultStarAnnotation :: Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc -> Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation+noDefaultStarAnnotationStarEtcParamNoDefaultStarAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+        Core.projectionFieldName = (Core.Name "paramNoDefaultStarAnnotation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the keywords field of hydra.python.syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcWithKeywords :: Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc -> Typed.TypedTerm (Maybe Syntax.Keywords) -> Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcWithKeywords original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefaultStarAnnotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+              Core.projectionFieldName = (Core.Name "paramNoDefaultStarAnnotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+              Core.projectionFieldName = (Core.Name "paramMaybeDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the paramMaybeDefault field of hydra.python.syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcWithParamMaybeDefault :: Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc -> Typed.TypedTerm [Syntax.ParamMaybeDefault] -> Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcWithParamMaybeDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefaultStarAnnotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+              Core.projectionFieldName = (Core.Name "paramNoDefaultStarAnnotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+              Core.projectionFieldName = (Core.Name "keywords")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramNoDefaultStarAnnotation field of hydra.python.syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcWithParamNoDefaultStarAnnotation :: Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc -> Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation -> Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcWithParamNoDefaultStarAnnotation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefaultStarAnnotation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+              Core.projectionFieldName = (Core.Name "paramMaybeDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"),+              Core.projectionFieldName = (Core.Name "keywords")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.NoDefaultStarEtc+noDefaultStarEtc :: Typed.TypedTerm Syntax.ParamNoDefault -> Typed.TypedTerm [Syntax.ParamMaybeDefault] -> Typed.TypedTerm (Maybe Syntax.Keywords) -> Typed.TypedTerm Syntax.NoDefaultStarEtc+noDefaultStarEtc paramNoDefault paramMaybeDefault keywords =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramNoDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramMaybeDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Typed.unTypedTerm keywords)}]}))++-- | DSL accessor for the keywords field of hydra.python.syntax.NoDefaultStarEtc+noDefaultStarEtcKeywords :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm (Maybe Syntax.Keywords)+noDefaultStarEtcKeywords x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+        Core.projectionFieldName = (Core.Name "keywords")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramMaybeDefault field of hydra.python.syntax.NoDefaultStarEtc+noDefaultStarEtcParamMaybeDefault :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm [Syntax.ParamMaybeDefault]+noDefaultStarEtcParamMaybeDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+        Core.projectionFieldName = (Core.Name "paramMaybeDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramNoDefault field of hydra.python.syntax.NoDefaultStarEtc+noDefaultStarEtcParamNoDefault :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm Syntax.ParamNoDefault+noDefaultStarEtcParamNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+        Core.projectionFieldName = (Core.Name "paramNoDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the keywords field of hydra.python.syntax.NoDefaultStarEtc+noDefaultStarEtcWithKeywords :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm (Maybe Syntax.Keywords) -> Typed.TypedTerm Syntax.NoDefaultStarEtc+noDefaultStarEtcWithKeywords original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+              Core.projectionFieldName = (Core.Name "paramMaybeDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the paramMaybeDefault field of hydra.python.syntax.NoDefaultStarEtc+noDefaultStarEtcWithParamMaybeDefault :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm [Syntax.ParamMaybeDefault] -> Typed.TypedTerm Syntax.NoDefaultStarEtc+noDefaultStarEtcWithParamMaybeDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+              Core.projectionFieldName = (Core.Name "keywords")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramNoDefault field of hydra.python.syntax.NoDefaultStarEtc+noDefaultStarEtcWithParamNoDefault :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm Syntax.ParamNoDefault -> Typed.TypedTerm Syntax.NoDefaultStarEtc+noDefaultStarEtcWithParamNoDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramMaybeDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+              Core.projectionFieldName = (Core.Name "paramMaybeDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keywords"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.NoDefaultStarEtc"),+              Core.projectionFieldName = (Core.Name "keywords")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the float variant of hydra.python.syntax.Number+numberFloat :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.Number+numberFloat x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Number"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the imaginary variant of hydra.python.syntax.Number+numberImaginary :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.Number+numberImaginary x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Number"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "imaginary"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the integer variant of hydra.python.syntax.Number+numberInteger :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.Number+numberInteger x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Number"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "integer"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.OpenSequencePattern+openSequencePattern :: Typed.TypedTerm Syntax.MaybeStarPattern -> Typed.TypedTerm (Maybe Syntax.MaybeSequencePattern) -> Typed.TypedTerm Syntax.OpenSequencePattern+openSequencePattern head tail =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.OpenSequencePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Typed.unTypedTerm head)},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Typed.unTypedTerm tail)}]}))++-- | DSL accessor for the head field of hydra.python.syntax.OpenSequencePattern+openSequencePatternHead :: Typed.TypedTerm Syntax.OpenSequencePattern -> Typed.TypedTerm Syntax.MaybeStarPattern+openSequencePatternHead x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.OpenSequencePattern"),+        Core.projectionFieldName = (Core.Name "head")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tail field of hydra.python.syntax.OpenSequencePattern+openSequencePatternTail :: Typed.TypedTerm Syntax.OpenSequencePattern -> Typed.TypedTerm (Maybe Syntax.MaybeSequencePattern)+openSequencePatternTail x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.OpenSequencePattern"),+        Core.projectionFieldName = (Core.Name "tail")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the head field of hydra.python.syntax.OpenSequencePattern+openSequencePatternWithHead :: Typed.TypedTerm Syntax.OpenSequencePattern -> Typed.TypedTerm Syntax.MaybeStarPattern -> Typed.TypedTerm Syntax.OpenSequencePattern+openSequencePatternWithHead original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.OpenSequencePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.OpenSequencePattern"),+              Core.projectionFieldName = (Core.Name "tail")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tail field of hydra.python.syntax.OpenSequencePattern+openSequencePatternWithTail :: Typed.TypedTerm Syntax.OpenSequencePattern -> Typed.TypedTerm (Maybe Syntax.MaybeSequencePattern) -> Typed.TypedTerm Syntax.OpenSequencePattern+openSequencePatternWithTail original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.OpenSequencePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.OpenSequencePattern"),+              Core.projectionFieldName = (Core.Name "head")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.python.syntax.OrPattern wrapper+orPattern :: Typed.TypedTerm [Syntax.ClosedPattern] -> Typed.TypedTerm Syntax.OrPattern+orPattern x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.OrPattern"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.Param+param :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Annotation) -> Typed.TypedTerm Syntax.Param+param name annotation =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Param"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Typed.unTypedTerm annotation)}]}))++-- | DSL accessor for the annotation field of hydra.python.syntax.Param+paramAnnotation :: Typed.TypedTerm Syntax.Param -> Typed.TypedTerm (Maybe Syntax.Annotation)+paramAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Param"),+        Core.projectionFieldName = (Core.Name "annotation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.ParamMaybeDefault+paramMaybeDefault :: Typed.TypedTerm Syntax.Param -> Typed.TypedTerm (Maybe Syntax.Default) -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ParamMaybeDefault+paramMaybeDefault param default_ typeComment =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Typed.unTypedTerm param)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm default_)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm typeComment)}]}))++-- | DSL accessor for the default field of hydra.python.syntax.ParamMaybeDefault+paramMaybeDefaultDefault :: Typed.TypedTerm Syntax.ParamMaybeDefault -> Typed.TypedTerm (Maybe Syntax.Default)+paramMaybeDefaultDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+        Core.projectionFieldName = (Core.Name "default")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the param field of hydra.python.syntax.ParamMaybeDefault+paramMaybeDefaultParam :: Typed.TypedTerm Syntax.ParamMaybeDefault -> Typed.TypedTerm Syntax.Param+paramMaybeDefaultParam x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+        Core.projectionFieldName = (Core.Name "param")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeComment field of hydra.python.syntax.ParamMaybeDefault+paramMaybeDefaultTypeComment :: Typed.TypedTerm Syntax.ParamMaybeDefault -> Typed.TypedTerm (Maybe Syntax.TypeComment)+paramMaybeDefaultTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+        Core.projectionFieldName = (Core.Name "typeComment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the default field of hydra.python.syntax.ParamMaybeDefault+paramMaybeDefaultWithDefault :: Typed.TypedTerm Syntax.ParamMaybeDefault -> Typed.TypedTerm (Maybe Syntax.Default) -> Typed.TypedTerm Syntax.ParamMaybeDefault+paramMaybeDefaultWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+              Core.projectionFieldName = (Core.Name "param")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the param field of hydra.python.syntax.ParamMaybeDefault+paramMaybeDefaultWithParam :: Typed.TypedTerm Syntax.ParamMaybeDefault -> Typed.TypedTerm Syntax.Param -> Typed.TypedTerm Syntax.ParamMaybeDefault+paramMaybeDefaultWithParam original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          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.python.syntax.ParamMaybeDefault"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeComment field of hydra.python.syntax.ParamMaybeDefault+paramMaybeDefaultWithTypeComment :: Typed.TypedTerm Syntax.ParamMaybeDefault -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ParamMaybeDefault+paramMaybeDefaultWithTypeComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamMaybeDefault"),+              Core.projectionFieldName = (Core.Name "param")})),+            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.python.syntax.ParamMaybeDefault"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the name field of hydra.python.syntax.Param+paramName :: Typed.TypedTerm Syntax.Param -> Typed.TypedTerm Syntax.Name+paramName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Param"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.ParamNoDefault+paramNoDefault :: Typed.TypedTerm Syntax.Param -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ParamNoDefault+paramNoDefault param typeComment =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Typed.unTypedTerm param)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm typeComment)}]}))++-- | DSL accessor for the param field of hydra.python.syntax.ParamNoDefault+paramNoDefaultParam :: Typed.TypedTerm Syntax.ParamNoDefault -> Typed.TypedTerm Syntax.Param+paramNoDefaultParam x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefault"),+        Core.projectionFieldName = (Core.Name "param")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.ParamNoDefaultParameters+paramNoDefaultParameters :: Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.ParamNoDefaultParameters+paramNoDefaultParameters paramNoDefault paramWithDefault starEtc =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramNoDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramWithDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm starEtc)}]}))++-- | DSL accessor for the paramNoDefault field of hydra.python.syntax.ParamNoDefaultParameters+paramNoDefaultParametersParamNoDefault :: Typed.TypedTerm Syntax.ParamNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamNoDefault]+paramNoDefaultParametersParamNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+        Core.projectionFieldName = (Core.Name "paramNoDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramWithDefault field of hydra.python.syntax.ParamNoDefaultParameters+paramNoDefaultParametersParamWithDefault :: Typed.TypedTerm Syntax.ParamNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault]+paramNoDefaultParametersParamWithDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+        Core.projectionFieldName = (Core.Name "paramWithDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the starEtc field of hydra.python.syntax.ParamNoDefaultParameters+paramNoDefaultParametersStarEtc :: Typed.TypedTerm Syntax.ParamNoDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc)+paramNoDefaultParametersStarEtc x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+        Core.projectionFieldName = (Core.Name "starEtc")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the paramNoDefault field of hydra.python.syntax.ParamNoDefaultParameters+paramNoDefaultParametersWithParamNoDefault :: Typed.TypedTerm Syntax.ParamNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm Syntax.ParamNoDefaultParameters+paramNoDefaultParametersWithParamNoDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramWithDefault field of hydra.python.syntax.ParamNoDefaultParameters+paramNoDefaultParametersWithParamWithDefault :: Typed.TypedTerm Syntax.ParamNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm Syntax.ParamNoDefaultParameters+paramNoDefaultParametersWithParamWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the starEtc field of hydra.python.syntax.ParamNoDefaultParameters+paramNoDefaultParametersWithStarEtc :: Typed.TypedTerm Syntax.ParamNoDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.ParamNoDefaultParameters+paramNoDefaultParametersWithStarEtc original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotation :: Typed.TypedTerm Syntax.ParamStarAnnotation -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotation paramStarAnnotation typeComment =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramStarAnnotation"),+          Core.fieldTerm = (Typed.unTypedTerm paramStarAnnotation)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm typeComment)}]}))++-- | DSL accessor for the paramStarAnnotation field of hydra.python.syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotationParamStarAnnotation :: Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation -> Typed.TypedTerm Syntax.ParamStarAnnotation+paramNoDefaultStarAnnotationParamStarAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation"),+        Core.projectionFieldName = (Core.Name "paramStarAnnotation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeComment field of hydra.python.syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotationTypeComment :: Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation -> Typed.TypedTerm (Maybe Syntax.TypeComment)+paramNoDefaultStarAnnotationTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation"),+        Core.projectionFieldName = (Core.Name "typeComment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the paramStarAnnotation field of hydra.python.syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotationWithParamStarAnnotation :: Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation -> Typed.TypedTerm Syntax.ParamStarAnnotation -> Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotationWithParamStarAnnotation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramStarAnnotation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeComment field of hydra.python.syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotationWithTypeComment :: Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotationWithTypeComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramStarAnnotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation"),+              Core.projectionFieldName = (Core.Name "paramStarAnnotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the typeComment field of hydra.python.syntax.ParamNoDefault+paramNoDefaultTypeComment :: Typed.TypedTerm Syntax.ParamNoDefault -> Typed.TypedTerm (Maybe Syntax.TypeComment)+paramNoDefaultTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefault"),+        Core.projectionFieldName = (Core.Name "typeComment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the param field of hydra.python.syntax.ParamNoDefault+paramNoDefaultWithParam :: Typed.TypedTerm Syntax.ParamNoDefault -> Typed.TypedTerm Syntax.Param -> Typed.TypedTerm Syntax.ParamNoDefault+paramNoDefaultWithParam original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefault"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeComment field of hydra.python.syntax.ParamNoDefault+paramNoDefaultWithTypeComment :: Typed.TypedTerm Syntax.ParamNoDefault -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ParamNoDefault+paramNoDefaultWithTypeComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamNoDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamNoDefault"),+              Core.projectionFieldName = (Core.Name "param")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.ParamStarAnnotation+paramStarAnnotation :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.StarAnnotation -> Typed.TypedTerm Syntax.ParamStarAnnotation+paramStarAnnotation name annotation =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamStarAnnotation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Typed.unTypedTerm annotation)}]}))++-- | DSL accessor for the annotation field of hydra.python.syntax.ParamStarAnnotation+paramStarAnnotationAnnotation :: Typed.TypedTerm Syntax.ParamStarAnnotation -> Typed.TypedTerm Syntax.StarAnnotation+paramStarAnnotationAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamStarAnnotation"),+        Core.projectionFieldName = (Core.Name "annotation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.ParamStarAnnotation+paramStarAnnotationName :: Typed.TypedTerm Syntax.ParamStarAnnotation -> Typed.TypedTerm Syntax.Name+paramStarAnnotationName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamStarAnnotation"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the annotation field of hydra.python.syntax.ParamStarAnnotation+paramStarAnnotationWithAnnotation :: Typed.TypedTerm Syntax.ParamStarAnnotation -> Typed.TypedTerm Syntax.StarAnnotation -> Typed.TypedTerm Syntax.ParamStarAnnotation+paramStarAnnotationWithAnnotation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamStarAnnotation"),+      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.python.syntax.ParamStarAnnotation"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.ParamStarAnnotation+paramStarAnnotationWithName :: Typed.TypedTerm Syntax.ParamStarAnnotation -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ParamStarAnnotation+paramStarAnnotationWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamStarAnnotation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamStarAnnotation"),+              Core.projectionFieldName = (Core.Name "annotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the annotation field of hydra.python.syntax.Param+paramWithAnnotation :: Typed.TypedTerm Syntax.Param -> Typed.TypedTerm (Maybe Syntax.Annotation) -> Typed.TypedTerm Syntax.Param+paramWithAnnotation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Param"),+      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.python.syntax.Param"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.ParamWithDefault+paramWithDefault :: Typed.TypedTerm Syntax.Param -> Typed.TypedTerm Syntax.Default -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ParamWithDefault+paramWithDefault param default_ typeComment =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Typed.unTypedTerm param)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm default_)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm typeComment)}]}))++-- | DSL accessor for the default field of hydra.python.syntax.ParamWithDefault+paramWithDefaultDefault :: Typed.TypedTerm Syntax.ParamWithDefault -> Typed.TypedTerm Syntax.Default+paramWithDefaultDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+        Core.projectionFieldName = (Core.Name "default")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the param field of hydra.python.syntax.ParamWithDefault+paramWithDefaultParam :: Typed.TypedTerm Syntax.ParamWithDefault -> Typed.TypedTerm Syntax.Param+paramWithDefaultParam x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+        Core.projectionFieldName = (Core.Name "param")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.ParamWithDefaultParameters+paramWithDefaultParameters :: Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.ParamWithDefaultParameters+paramWithDefaultParameters paramWithDefault starEtc =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamWithDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramWithDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm starEtc)}]}))++-- | DSL accessor for the paramWithDefault field of hydra.python.syntax.ParamWithDefaultParameters+paramWithDefaultParametersParamWithDefault :: Typed.TypedTerm Syntax.ParamWithDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault]+paramWithDefaultParametersParamWithDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefaultParameters"),+        Core.projectionFieldName = (Core.Name "paramWithDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the starEtc field of hydra.python.syntax.ParamWithDefaultParameters+paramWithDefaultParametersStarEtc :: Typed.TypedTerm Syntax.ParamWithDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc)+paramWithDefaultParametersStarEtc x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefaultParameters"),+        Core.projectionFieldName = (Core.Name "starEtc")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the paramWithDefault field of hydra.python.syntax.ParamWithDefaultParameters+paramWithDefaultParametersWithParamWithDefault :: Typed.TypedTerm Syntax.ParamWithDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm Syntax.ParamWithDefaultParameters+paramWithDefaultParametersWithParamWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamWithDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefaultParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the starEtc field of hydra.python.syntax.ParamWithDefaultParameters+paramWithDefaultParametersWithStarEtc :: Typed.TypedTerm Syntax.ParamWithDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.ParamWithDefaultParameters+paramWithDefaultParametersWithStarEtc original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamWithDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the typeComment field of hydra.python.syntax.ParamWithDefault+paramWithDefaultTypeComment :: Typed.TypedTerm Syntax.ParamWithDefault -> Typed.TypedTerm (Maybe Syntax.TypeComment)+paramWithDefaultTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+        Core.projectionFieldName = (Core.Name "typeComment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the default field of hydra.python.syntax.ParamWithDefault+paramWithDefaultWithDefault :: Typed.TypedTerm Syntax.ParamWithDefault -> Typed.TypedTerm Syntax.Default -> Typed.TypedTerm Syntax.ParamWithDefault+paramWithDefaultWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+              Core.projectionFieldName = (Core.Name "param")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the param field of hydra.python.syntax.ParamWithDefault+paramWithDefaultWithParam :: Typed.TypedTerm Syntax.ParamWithDefault -> Typed.TypedTerm Syntax.Param -> Typed.TypedTerm Syntax.ParamWithDefault+paramWithDefaultWithParam original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          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.python.syntax.ParamWithDefault"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeComment field of hydra.python.syntax.ParamWithDefault+paramWithDefaultWithTypeComment :: Typed.TypedTerm Syntax.ParamWithDefault -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.ParamWithDefault+paramWithDefaultWithTypeComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "param"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ParamWithDefault"),+              Core.projectionFieldName = (Core.Name "param")})),+            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.python.syntax.ParamWithDefault"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.Param+paramWithName :: Typed.TypedTerm Syntax.Param -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Param+paramWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Param"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Param"),+              Core.projectionFieldName = (Core.Name "annotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the paramNoDefault variant of hydra.python.syntax.Parameters+parametersParamNoDefault :: Typed.TypedTerm Syntax.ParamNoDefaultParameters -> Typed.TypedTerm Syntax.Parameters+parametersParamNoDefault x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Parameters"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "paramNoDefault"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the paramWithDefault variant of hydra.python.syntax.Parameters+parametersParamWithDefault :: Typed.TypedTerm Syntax.ParamWithDefaultParameters -> Typed.TypedTerm Syntax.Parameters+parametersParamWithDefault x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Parameters"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "paramWithDefault"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the slashNoDefault variant of hydra.python.syntax.Parameters+parametersSlashNoDefault :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm Syntax.Parameters+parametersSlashNoDefault x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Parameters"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "slashNoDefault"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the slashWithDefault variant of hydra.python.syntax.Parameters+parametersSlashWithDefault :: Typed.TypedTerm Syntax.SlashWithDefaultParameters -> Typed.TypedTerm Syntax.Parameters+parametersSlashWithDefault x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Parameters"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "slashWithDefault"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starEtc variant of hydra.python.syntax.Parameters+parametersStarEtc :: Typed.TypedTerm Syntax.StarEtc -> Typed.TypedTerm Syntax.Parameters+parametersStarEtc x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Parameters"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starEtc"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the as variant of hydra.python.syntax.Pattern+patternAs :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.Pattern+patternAs x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Pattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "as"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.PatternCaptureTarget wrapper+patternCaptureTarget :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PatternCaptureTarget+patternCaptureTarget x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.PatternCaptureTarget"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the or variant of hydra.python.syntax.Pattern+patternOr :: Typed.TypedTerm Syntax.OrPattern -> Typed.TypedTerm Syntax.Pattern+patternOr x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Pattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "or"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the pattern variant of hydra.python.syntax.Patterns+patternsPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.Patterns+patternsPattern x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Patterns"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pattern"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the sequence variant of hydra.python.syntax.Patterns+patternsSequence :: Typed.TypedTerm Syntax.OpenSequencePattern -> Typed.TypedTerm Syntax.Patterns+patternsSequence x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Patterns"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "sequence"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the minus variant of hydra.python.syntax.PlusOrMinus+plusOrMinusMinus :: Typed.TypedTerm Syntax.PlusOrMinus+plusOrMinusMinus =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PlusOrMinus"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "minus"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the plus variant of hydra.python.syntax.PlusOrMinus+plusOrMinusPlus :: Typed.TypedTerm Syntax.PlusOrMinus+plusOrMinusPlus =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PlusOrMinus"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "plus"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the assignment variant of hydra.python.syntax.PosArg+posArgAssignment :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.PosArg+posArgAssignment x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PosArg"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "assignment"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the expression variant of hydra.python.syntax.PosArg+posArgExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PosArg+posArgExpression x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PosArg"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "expression"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starred variant of hydra.python.syntax.PosArg+posArgStarred :: Typed.TypedTerm Syntax.StarredExpression -> Typed.TypedTerm Syntax.PosArg+posArgStarred x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PosArg"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starred"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.PositionalPatterns wrapper+positionalPatterns :: Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.PositionalPatterns+positionalPatterns x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.PositionalPatterns"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.Power+power :: Typed.TypedTerm Syntax.AwaitPrimary -> Typed.TypedTerm (Maybe Syntax.Factor) -> Typed.TypedTerm Syntax.Power+power lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Power"),+      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.python.syntax.Power+powerLhs :: Typed.TypedTerm Syntax.Power -> Typed.TypedTerm Syntax.AwaitPrimary+powerLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Power"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.Power+powerRhs :: Typed.TypedTerm Syntax.Power -> Typed.TypedTerm (Maybe Syntax.Factor)+powerRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Power"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.Power+powerWithLhs :: Typed.TypedTerm Syntax.Power -> Typed.TypedTerm Syntax.AwaitPrimary -> Typed.TypedTerm Syntax.Power+powerWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Power"),+      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.python.syntax.Power"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.Power+powerWithRhs :: Typed.TypedTerm Syntax.Power -> Typed.TypedTerm (Maybe Syntax.Factor) -> Typed.TypedTerm Syntax.Power+powerWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Power"),+      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.python.syntax.Power"),+              Core.projectionFieldName = (Core.Name "lhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the compound variant of hydra.python.syntax.Primary+primaryCompound :: Typed.TypedTerm Syntax.PrimaryWithRhs -> Typed.TypedTerm Syntax.Primary+primaryCompound x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Primary"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "compound"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the call variant of hydra.python.syntax.PrimaryRhs+primaryRhsCall :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm Syntax.PrimaryRhs+primaryRhsCall x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PrimaryRhs"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "call"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the genexp variant of hydra.python.syntax.PrimaryRhs+primaryRhsGenexp :: Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.PrimaryRhs+primaryRhsGenexp x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PrimaryRhs"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "genexp"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the project variant of hydra.python.syntax.PrimaryRhs+primaryRhsProject :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PrimaryRhs+primaryRhsProject x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PrimaryRhs"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "project"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the slices variant of hydra.python.syntax.PrimaryRhs+primaryRhsSlices :: Typed.TypedTerm Syntax.Slices -> Typed.TypedTerm Syntax.PrimaryRhs+primaryRhsSlices x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.PrimaryRhs"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "slices"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.Primary+primarySimple :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.Primary+primarySimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Primary"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.PrimaryWithRhs+primaryWithRhs :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.PrimaryRhs -> Typed.TypedTerm Syntax.PrimaryWithRhs+primaryWithRhs primary rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.PrimaryWithRhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm primary)},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the primary field of hydra.python.syntax.PrimaryWithRhs+primaryWithRhsPrimary :: Typed.TypedTerm Syntax.PrimaryWithRhs -> Typed.TypedTerm Syntax.Primary+primaryWithRhsPrimary x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.PrimaryWithRhs"),+        Core.projectionFieldName = (Core.Name "primary")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.PrimaryWithRhs+primaryWithRhsRhs :: Typed.TypedTerm Syntax.PrimaryWithRhs -> Typed.TypedTerm Syntax.PrimaryRhs+primaryWithRhsRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.PrimaryWithRhs"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the primary field of hydra.python.syntax.PrimaryWithRhs+primaryWithRhsWithPrimary :: Typed.TypedTerm Syntax.PrimaryWithRhs -> Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.PrimaryWithRhs+primaryWithRhsWithPrimary original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.PrimaryWithRhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          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.python.syntax.PrimaryWithRhs"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.PrimaryWithRhs+primaryWithRhsWithRhs :: Typed.TypedTerm Syntax.PrimaryWithRhs -> Typed.TypedTerm Syntax.PrimaryRhs -> Typed.TypedTerm Syntax.PrimaryWithRhs+primaryWithRhsWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.PrimaryWithRhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.PrimaryWithRhs"),+              Core.projectionFieldName = (Core.Name "primary")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the double variant of hydra.python.syntax.QuoteStyle+quoteStyleDouble :: Typed.TypedTerm Syntax.QuoteStyle+quoteStyleDouble =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.QuoteStyle"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "double"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the single variant of hydra.python.syntax.QuoteStyle+quoteStyleSingle :: Typed.TypedTerm Syntax.QuoteStyle+quoteStyleSingle =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.QuoteStyle"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "single"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the tripleDouble variant of hydra.python.syntax.QuoteStyle+quoteStyleTripleDouble :: Typed.TypedTerm Syntax.QuoteStyle+quoteStyleTripleDouble =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.QuoteStyle"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "tripleDouble"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the tripleSingle variant of hydra.python.syntax.QuoteStyle+quoteStyleTripleSingle :: Typed.TypedTerm Syntax.QuoteStyle+quoteStyleTripleSingle =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.QuoteStyle"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "tripleSingle"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.python.syntax.RaiseExpression+raiseExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.RaiseExpression+raiseExpression expression from =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.RaiseExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)},+        Core.Field {+          Core.fieldName = (Core.Name "from"),+          Core.fieldTerm = (Typed.unTypedTerm from)}]}))++-- | DSL accessor for the expression field of hydra.python.syntax.RaiseExpression+raiseExpressionExpression :: Typed.TypedTerm Syntax.RaiseExpression -> Typed.TypedTerm Syntax.Expression+raiseExpressionExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.RaiseExpression"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the from field of hydra.python.syntax.RaiseExpression+raiseExpressionFrom :: Typed.TypedTerm Syntax.RaiseExpression -> Typed.TypedTerm (Maybe Syntax.Expression)+raiseExpressionFrom x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.RaiseExpression"),+        Core.projectionFieldName = (Core.Name "from")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expression field of hydra.python.syntax.RaiseExpression+raiseExpressionWithExpression :: Typed.TypedTerm Syntax.RaiseExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RaiseExpression+raiseExpressionWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.RaiseExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "from"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.RaiseExpression"),+              Core.projectionFieldName = (Core.Name "from")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the from field of hydra.python.syntax.RaiseExpression+raiseExpressionWithFrom :: Typed.TypedTerm Syntax.RaiseExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.RaiseExpression+raiseExpressionWithFrom original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.RaiseExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.RaiseExpression"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "from"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.python.syntax.RaiseStatement wrapper+raiseStatement :: Typed.TypedTerm (Maybe Syntax.RaiseExpression) -> Typed.TypedTerm Syntax.RaiseStatement+raiseStatement x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.RaiseStatement"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the float variant of hydra.python.syntax.RealNumber+realNumberFloat :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.RealNumber+realNumberFloat x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.RealNumber"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the integer variant of hydra.python.syntax.RealNumber+realNumberInteger :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.RealNumber+realNumberInteger x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.RealNumber"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "integer"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the dot variant of hydra.python.syntax.RelativeImportPrefix+relativeImportPrefixDot :: Typed.TypedTerm Syntax.RelativeImportPrefix+relativeImportPrefixDot =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.RelativeImportPrefix"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "dot"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the ellipsis variant of hydra.python.syntax.RelativeImportPrefix+relativeImportPrefixEllipsis :: Typed.TypedTerm Syntax.RelativeImportPrefix+relativeImportPrefixEllipsis =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.RelativeImportPrefix"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "ellipsis"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for the hydra.python.syntax.ReturnStatement wrapper+returnStatement :: Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm Syntax.ReturnStatement+returnStatement x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ReturnStatement"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the list variant of hydra.python.syntax.SequencePattern+sequencePatternList :: Typed.TypedTerm (Maybe Syntax.MaybeSequencePattern) -> Typed.TypedTerm Syntax.SequencePattern+sequencePatternList x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SequencePattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "list"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the tuple variant of hydra.python.syntax.SequencePattern+sequencePatternTuple :: Typed.TypedTerm (Maybe Syntax.OpenSequencePattern) -> Typed.TypedTerm Syntax.SequencePattern+sequencePatternTuple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SequencePattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "tuple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.Set wrapper+set :: Typed.TypedTerm [Syntax.StarNamedExpression] -> Typed.TypedTerm Syntax.Set+set x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Set"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.Setcomp+setcomp :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Setcomp+setcomp expression forIfClauses =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Setcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Typed.unTypedTerm forIfClauses)}]}))++-- | DSL accessor for the expression field of hydra.python.syntax.Setcomp+setcompExpression :: Typed.TypedTerm Syntax.Setcomp -> Typed.TypedTerm Syntax.NamedExpression+setcompExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Setcomp"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the forIfClauses field of hydra.python.syntax.Setcomp+setcompForIfClauses :: Typed.TypedTerm Syntax.Setcomp -> Typed.TypedTerm Syntax.ForIfClauses+setcompForIfClauses x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Setcomp"),+        Core.projectionFieldName = (Core.Name "forIfClauses")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expression field of hydra.python.syntax.Setcomp+setcompWithExpression :: Typed.TypedTerm Syntax.Setcomp -> Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Setcomp+setcompWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Setcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Setcomp"),+              Core.projectionFieldName = (Core.Name "forIfClauses")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the forIfClauses field of hydra.python.syntax.Setcomp+setcompWithForIfClauses :: Typed.TypedTerm Syntax.Setcomp -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Setcomp+setcompWithForIfClauses original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Setcomp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Setcomp"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "forIfClauses"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.ShiftExpression+shiftExpression :: Typed.TypedTerm (Maybe Syntax.ShiftLhs) -> Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm Syntax.ShiftExpression+shiftExpression lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ShiftExpression"),+      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.python.syntax.ShiftExpression+shiftExpressionLhs :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm (Maybe Syntax.ShiftLhs)+shiftExpressionLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ShiftExpression"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.ShiftExpression+shiftExpressionRhs :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.Sum+shiftExpressionRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ShiftExpression"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.ShiftExpression+shiftExpressionWithLhs :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm (Maybe Syntax.ShiftLhs) -> Typed.TypedTerm Syntax.ShiftExpression+shiftExpressionWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ShiftExpression"),+      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.python.syntax.ShiftExpression"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.ShiftExpression+shiftExpressionWithRhs :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm Syntax.ShiftExpression+shiftExpressionWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ShiftExpression"),+      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.python.syntax.ShiftExpression"),+              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.python.syntax.ShiftLhs+shiftLhs :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.ShiftOp -> Typed.TypedTerm Syntax.ShiftLhs+shiftLhs operand operator =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ShiftLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Typed.unTypedTerm operand)},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Typed.unTypedTerm operator)}]}))++-- | DSL accessor for the operand field of hydra.python.syntax.ShiftLhs+shiftLhsOperand :: Typed.TypedTerm Syntax.ShiftLhs -> Typed.TypedTerm Syntax.ShiftExpression+shiftLhsOperand x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ShiftLhs"),+        Core.projectionFieldName = (Core.Name "operand")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the operator field of hydra.python.syntax.ShiftLhs+shiftLhsOperator :: Typed.TypedTerm Syntax.ShiftLhs -> Typed.TypedTerm Syntax.ShiftOp+shiftLhsOperator x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.ShiftLhs"),+        Core.projectionFieldName = (Core.Name "operator")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the operand field of hydra.python.syntax.ShiftLhs+shiftLhsWithOperand :: Typed.TypedTerm Syntax.ShiftLhs -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.ShiftLhs+shiftLhsWithOperand original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ShiftLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ShiftLhs"),+              Core.projectionFieldName = (Core.Name "operator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the operator field of hydra.python.syntax.ShiftLhs+shiftLhsWithOperator :: Typed.TypedTerm Syntax.ShiftLhs -> Typed.TypedTerm Syntax.ShiftOp -> Typed.TypedTerm Syntax.ShiftLhs+shiftLhsWithOperator original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.ShiftLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.ShiftLhs"),+              Core.projectionFieldName = (Core.Name "operand")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the left variant of hydra.python.syntax.ShiftOp+shiftOpLeft :: Typed.TypedTerm Syntax.ShiftOp+shiftOpLeft =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ShiftOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "left"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the right variant of hydra.python.syntax.ShiftOp+shiftOpRight :: Typed.TypedTerm Syntax.ShiftOp+shiftOpRight =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.ShiftOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "right"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the number variant of hydra.python.syntax.SignedNumber+signedNumberNumber :: Typed.TypedTerm Syntax.Number -> Typed.TypedTerm Syntax.SignedNumber+signedNumberNumber x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SignedNumber"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "number"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the sign variant of hydra.python.syntax.SignedNumber+signedNumberSign :: Typed.TypedTerm Syntax.PlusOrMinus -> Typed.TypedTerm Syntax.SignedNumber+signedNumberSign x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SignedNumber"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "sign"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the number variant of hydra.python.syntax.SignedRealNumber+signedRealNumberNumber :: Typed.TypedTerm Syntax.RealNumber -> Typed.TypedTerm Syntax.SignedRealNumber+signedRealNumberNumber x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SignedRealNumber"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "number"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the sign variant of hydra.python.syntax.SignedRealNumber+signedRealNumberSign :: Typed.TypedTerm Syntax.PlusOrMinus -> Typed.TypedTerm Syntax.SignedRealNumber+signedRealNumberSign x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SignedRealNumber"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "sign"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the assert variant of hydra.python.syntax.SimpleStatement+simpleStatementAssert :: Typed.TypedTerm Syntax.AssertStatement -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementAssert x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "assert"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the assignment variant of hydra.python.syntax.SimpleStatement+simpleStatementAssignment :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementAssignment x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "assignment"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the break variant of hydra.python.syntax.SimpleStatement+simpleStatementBreak :: Typed.TypedTerm Syntax.SimpleStatement+simpleStatementBreak =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "break"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the continue variant of hydra.python.syntax.SimpleStatement+simpleStatementContinue :: Typed.TypedTerm Syntax.SimpleStatement+simpleStatementContinue =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "continue"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the del variant of hydra.python.syntax.SimpleStatement+simpleStatementDel :: Typed.TypedTerm Syntax.DelStatement -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementDel x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "del"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the global variant of hydra.python.syntax.SimpleStatement+simpleStatementGlobal :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementGlobal x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "global"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the import variant of hydra.python.syntax.SimpleStatement+simpleStatementImport :: Typed.TypedTerm Syntax.ImportStatement -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementImport x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "import"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the nonlocal variant of hydra.python.syntax.SimpleStatement+simpleStatementNonlocal :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementNonlocal x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nonlocal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the pass variant of hydra.python.syntax.SimpleStatement+simpleStatementPass :: Typed.TypedTerm Syntax.SimpleStatement+simpleStatementPass =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pass"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the raise variant of hydra.python.syntax.SimpleStatement+simpleStatementRaise :: Typed.TypedTerm Syntax.RaiseStatement -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementRaise x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "raise"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the return variant of hydra.python.syntax.SimpleStatement+simpleStatementReturn :: Typed.TypedTerm Syntax.ReturnStatement -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementReturn x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "return"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starExpressions variant of hydra.python.syntax.SimpleStatement+simpleStatementStarExpressions :: Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementStarExpressions x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starExpressions"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the typeAlias variant of hydra.python.syntax.SimpleStatement+simpleStatementTypeAlias :: Typed.TypedTerm Syntax.TypeAlias -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementTypeAlias x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeAlias"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the yield variant of hydra.python.syntax.SimpleStatement+simpleStatementYield :: Typed.TypedTerm Syntax.YieldStatement -> Typed.TypedTerm Syntax.SimpleStatement+simpleStatementYield x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SimpleStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "yield"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.SimpleTypeParameter+simpleTypeParameter :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SimpleTypeParameter+simpleTypeParameter name bound default_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "bound"),+          Core.fieldTerm = (Typed.unTypedTerm bound)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))++-- | DSL accessor for the bound field of hydra.python.syntax.SimpleTypeParameter+simpleTypeParameterBound :: Typed.TypedTerm Syntax.SimpleTypeParameter -> Typed.TypedTerm (Maybe Syntax.Expression)+simpleTypeParameterBound x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+        Core.projectionFieldName = (Core.Name "bound")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the default field of hydra.python.syntax.SimpleTypeParameter+simpleTypeParameterDefault :: Typed.TypedTerm Syntax.SimpleTypeParameter -> Typed.TypedTerm (Maybe Syntax.Expression)+simpleTypeParameterDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+        Core.projectionFieldName = (Core.Name "default")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.SimpleTypeParameter+simpleTypeParameterName :: Typed.TypedTerm Syntax.SimpleTypeParameter -> Typed.TypedTerm Syntax.Name+simpleTypeParameterName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the bound field of hydra.python.syntax.SimpleTypeParameter+simpleTypeParameterWithBound :: Typed.TypedTerm Syntax.SimpleTypeParameter -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SimpleTypeParameter+simpleTypeParameterWithBound original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+      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.python.syntax.SimpleTypeParameter"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bound"),+          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.python.syntax.SimpleTypeParameter"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the default field of hydra.python.syntax.SimpleTypeParameter+simpleTypeParameterWithDefault :: Typed.TypedTerm Syntax.SimpleTypeParameter -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SimpleTypeParameter+simpleTypeParameterWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+      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.python.syntax.SimpleTypeParameter"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bound"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+              Core.projectionFieldName = (Core.Name "bound")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.SimpleTypeParameter+simpleTypeParameterWithName :: Typed.TypedTerm Syntax.SimpleTypeParameter -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SimpleTypeParameter+simpleTypeParameterWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "bound"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SimpleTypeParameter"),+              Core.projectionFieldName = (Core.Name "bound")})),+            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.python.syntax.SimpleTypeParameter"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the primaryAndName variant of hydra.python.syntax.SingleSubscriptAttributeTarget+singleSubscriptAttributeTargetPrimaryAndName :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.SingleSubscriptAttributeTarget+singleSubscriptAttributeTargetPrimaryAndName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SingleSubscriptAttributeTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primaryAndName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the primaryAndSlices variant of hydra.python.syntax.SingleSubscriptAttributeTarget+singleSubscriptAttributeTargetPrimaryAndSlices :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.SingleSubscriptAttributeTarget+singleSubscriptAttributeTargetPrimaryAndSlices x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SingleSubscriptAttributeTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primaryAndSlices"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the name variant of hydra.python.syntax.SingleTarget+singleTargetName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SingleTarget+singleTargetName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SingleTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "name"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the parens variant of hydra.python.syntax.SingleTarget+singleTargetParens :: Typed.TypedTerm Syntax.SingleTarget -> Typed.TypedTerm Syntax.SingleTarget+singleTargetParens x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SingleTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "parens"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the subscriptAttributeTarget variant of hydra.python.syntax.SingleTarget+singleTargetSubscriptAttributeTarget :: Typed.TypedTerm Syntax.SingleSubscriptAttributeTarget -> Typed.TypedTerm Syntax.SingleTarget+singleTargetSubscriptAttributeTarget x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SingleTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "subscriptAttributeTarget"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.SlashNoDefault wrapper+slashNoDefault :: Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm Syntax.SlashNoDefault+slashNoDefault x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.SlashNoDefault"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParameters :: Typed.TypedTerm Syntax.SlashNoDefault -> Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.SlashNoDefaultParameters+slashNoDefaultParameters slash paramNoDefault paramWithDefault starEtc =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slash"),+          Core.fieldTerm = (Typed.unTypedTerm slash)},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramNoDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramWithDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm starEtc)}]}))++-- | DSL accessor for the paramNoDefault field of hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersParamNoDefault :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamNoDefault]+slashNoDefaultParametersParamNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+        Core.projectionFieldName = (Core.Name "paramNoDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramWithDefault field of hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersParamWithDefault :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault]+slashNoDefaultParametersParamWithDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+        Core.projectionFieldName = (Core.Name "paramWithDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the slash field of hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersSlash :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm Syntax.SlashNoDefault+slashNoDefaultParametersSlash x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+        Core.projectionFieldName = (Core.Name "slash")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the starEtc field of hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersStarEtc :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc)+slashNoDefaultParametersStarEtc x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+        Core.projectionFieldName = (Core.Name "starEtc")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the paramNoDefault field of hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersWithParamNoDefault :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm Syntax.SlashNoDefaultParameters+slashNoDefaultParametersWithParamNoDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "slash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramWithDefault field of hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersWithParamWithDefault :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm Syntax.SlashNoDefaultParameters+slashNoDefaultParametersWithParamWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "slash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the slash field of hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersWithSlash :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm Syntax.SlashNoDefault -> Typed.TypedTerm Syntax.SlashNoDefaultParameters+slashNoDefaultParametersWithSlash original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slash"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the starEtc field of hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersWithStarEtc :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.SlashNoDefaultParameters+slashNoDefaultParametersWithStarEtc original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "slash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "slash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashNoDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.SlashWithDefault+slashWithDefault :: Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm Syntax.SlashWithDefault+slashWithDefault paramNoDefault paramWithDefault =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramNoDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramWithDefault)}]}))++-- | DSL accessor for the paramNoDefault field of hydra.python.syntax.SlashWithDefault+slashWithDefaultParamNoDefault :: Typed.TypedTerm Syntax.SlashWithDefault -> Typed.TypedTerm [Syntax.ParamNoDefault]+slashWithDefaultParamNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefault"),+        Core.projectionFieldName = (Core.Name "paramNoDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramWithDefault field of hydra.python.syntax.SlashWithDefault+slashWithDefaultParamWithDefault :: Typed.TypedTerm Syntax.SlashWithDefault -> Typed.TypedTerm [Syntax.ParamWithDefault]+slashWithDefaultParamWithDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefault"),+        Core.projectionFieldName = (Core.Name "paramWithDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.SlashWithDefaultParameters+slashWithDefaultParameters :: Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.SlashWithDefaultParameters+slashWithDefaultParameters paramNoDefault paramWithDefault starEtc =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramNoDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm paramWithDefault)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm starEtc)}]}))++-- | DSL accessor for the paramNoDefault field of hydra.python.syntax.SlashWithDefaultParameters+slashWithDefaultParametersParamNoDefault :: Typed.TypedTerm Syntax.SlashWithDefaultParameters -> Typed.TypedTerm [Syntax.ParamNoDefault]+slashWithDefaultParametersParamNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+        Core.projectionFieldName = (Core.Name "paramNoDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramWithDefault field of hydra.python.syntax.SlashWithDefaultParameters+slashWithDefaultParametersParamWithDefault :: Typed.TypedTerm Syntax.SlashWithDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault]+slashWithDefaultParametersParamWithDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+        Core.projectionFieldName = (Core.Name "paramWithDefault")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the starEtc field of hydra.python.syntax.SlashWithDefaultParameters+slashWithDefaultParametersStarEtc :: Typed.TypedTerm Syntax.SlashWithDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc)+slashWithDefaultParametersStarEtc x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+        Core.projectionFieldName = (Core.Name "starEtc")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the paramNoDefault field of hydra.python.syntax.SlashWithDefaultParameters+slashWithDefaultParametersWithParamNoDefault :: Typed.TypedTerm Syntax.SlashWithDefaultParameters -> Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm Syntax.SlashWithDefaultParameters+slashWithDefaultParametersWithParamNoDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramWithDefault field of hydra.python.syntax.SlashWithDefaultParameters+slashWithDefaultParametersWithParamWithDefault :: Typed.TypedTerm Syntax.SlashWithDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm Syntax.SlashWithDefaultParameters+slashWithDefaultParametersWithParamWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+              Core.projectionFieldName = (Core.Name "starEtc")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the starEtc field of hydra.python.syntax.SlashWithDefaultParameters+slashWithDefaultParametersWithStarEtc :: Typed.TypedTerm Syntax.SlashWithDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.SlashWithDefaultParameters+slashWithDefaultParametersWithStarEtc original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefaultParameters"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "starEtc"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the paramNoDefault field of hydra.python.syntax.SlashWithDefault+slashWithDefaultWithParamNoDefault :: Typed.TypedTerm Syntax.SlashWithDefault -> Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm Syntax.SlashWithDefault+slashWithDefaultWithParamNoDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefault"),+              Core.projectionFieldName = (Core.Name "paramWithDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramWithDefault field of hydra.python.syntax.SlashWithDefault+slashWithDefaultWithParamWithDefault :: Typed.TypedTerm Syntax.SlashWithDefault -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm Syntax.SlashWithDefault+slashWithDefaultWithParamWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SlashWithDefault"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "paramNoDefault"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SlashWithDefault"),+              Core.projectionFieldName = (Core.Name "paramNoDefault")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "paramWithDefault"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.SliceExpression+sliceExpression :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SliceExpression+sliceExpression start stop step =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "start"),+          Core.fieldTerm = (Typed.unTypedTerm start)},+        Core.Field {+          Core.fieldName = (Core.Name "stop"),+          Core.fieldTerm = (Typed.unTypedTerm stop)},+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm step)}]}))++-- | DSL accessor for the start field of hydra.python.syntax.SliceExpression+sliceExpressionStart :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm (Maybe Syntax.Expression)+sliceExpressionStart x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+        Core.projectionFieldName = (Core.Name "start")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the step field of hydra.python.syntax.SliceExpression+sliceExpressionStep :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm (Maybe Syntax.Expression)+sliceExpressionStep x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+        Core.projectionFieldName = (Core.Name "step")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the stop field of hydra.python.syntax.SliceExpression+sliceExpressionStop :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm (Maybe Syntax.Expression)+sliceExpressionStop x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+        Core.projectionFieldName = (Core.Name "stop")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the start field of hydra.python.syntax.SliceExpression+sliceExpressionWithStart :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SliceExpression+sliceExpressionWithStart original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "start"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "stop"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+              Core.projectionFieldName = (Core.Name "stop")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+              Core.projectionFieldName = (Core.Name "step")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the step field of hydra.python.syntax.SliceExpression+sliceExpressionWithStep :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SliceExpression+sliceExpressionWithStep original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "start"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+              Core.projectionFieldName = (Core.Name "start")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "stop"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+              Core.projectionFieldName = (Core.Name "stop")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the stop field of hydra.python.syntax.SliceExpression+sliceExpressionWithStop :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SliceExpression+sliceExpressionWithStop original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "start"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+              Core.projectionFieldName = (Core.Name "start")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "stop"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SliceExpression"),+              Core.projectionFieldName = (Core.Name "step")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the named variant of hydra.python.syntax.Slice+sliceNamed :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Slice+sliceNamed x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Slice"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "named"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the slice variant of hydra.python.syntax.SliceOrStarredExpression+sliceOrStarredExpressionSlice :: Typed.TypedTerm Syntax.Slice -> Typed.TypedTerm Syntax.SliceOrStarredExpression+sliceOrStarredExpressionSlice x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SliceOrStarredExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "slice"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starred variant of hydra.python.syntax.SliceOrStarredExpression+sliceOrStarredExpressionStarred :: Typed.TypedTerm Syntax.StarredExpression -> Typed.TypedTerm Syntax.SliceOrStarredExpression+sliceOrStarredExpressionStarred x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SliceOrStarredExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starred"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the slice_ variant of hydra.python.syntax.Slice+sliceSlice_ :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm Syntax.Slice+sliceSlice_ x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Slice"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "slice_"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.Slices+slices :: Typed.TypedTerm Syntax.Slice -> Typed.TypedTerm [Syntax.SliceOrStarredExpression] -> Typed.TypedTerm Syntax.Slices+slices head tail =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Slices"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Typed.unTypedTerm head)},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Typed.unTypedTerm tail)}]}))++-- | DSL accessor for the head field of hydra.python.syntax.Slices+slicesHead :: Typed.TypedTerm Syntax.Slices -> Typed.TypedTerm Syntax.Slice+slicesHead x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Slices"),+        Core.projectionFieldName = (Core.Name "head")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tail field of hydra.python.syntax.Slices+slicesTail :: Typed.TypedTerm Syntax.Slices -> Typed.TypedTerm [Syntax.SliceOrStarredExpression]+slicesTail x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Slices"),+        Core.projectionFieldName = (Core.Name "tail")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the head field of hydra.python.syntax.Slices+slicesWithHead :: Typed.TypedTerm Syntax.Slices -> Typed.TypedTerm Syntax.Slice -> Typed.TypedTerm Syntax.Slices+slicesWithHead original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Slices"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Slices"),+              Core.projectionFieldName = (Core.Name "tail")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tail field of hydra.python.syntax.Slices+slicesWithTail :: Typed.TypedTerm Syntax.Slices -> Typed.TypedTerm [Syntax.SliceOrStarredExpression] -> Typed.TypedTerm Syntax.Slices+slicesWithTail original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Slices"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "head"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.Slices"),+              Core.projectionFieldName = (Core.Name "head")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "tail"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.python.syntax.StarAnnotation wrapper+starAnnotation :: Typed.TypedTerm Syntax.StarExpression -> Typed.TypedTerm Syntax.StarAnnotation+starAnnotation x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarAnnotation"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the name variant of hydra.python.syntax.StarAtom+starAtomName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.StarAtom+starAtomName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "name"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starTargetsListSeq variant of hydra.python.syntax.StarAtom+starAtomStarTargetsListSeq :: Typed.TypedTerm (Maybe Syntax.StarTargetsListSeq) -> Typed.TypedTerm Syntax.StarAtom+starAtomStarTargetsListSeq x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starTargetsListSeq"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starTargetsTupleSeq variant of hydra.python.syntax.StarAtom+starAtomStarTargetsTupleSeq :: Typed.TypedTerm (Maybe Syntax.StarTargetsTupleSeq) -> Typed.TypedTerm Syntax.StarAtom+starAtomStarTargetsTupleSeq x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starTargetsTupleSeq"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the targetWithStarAtom variant of hydra.python.syntax.StarAtom+starAtomTargetWithStarAtom :: Typed.TypedTerm Syntax.TargetWithStarAtom -> Typed.TypedTerm Syntax.StarAtom+starAtomTargetWithStarAtom x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "targetWithStarAtom"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the keywords variant of hydra.python.syntax.StarEtc+starEtcKeywords :: Typed.TypedTerm Syntax.Keywords -> Typed.TypedTerm Syntax.StarEtc+starEtcKeywords x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarEtc"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "keywords"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starComma variant of hydra.python.syntax.StarEtc+starEtcStarComma :: Typed.TypedTerm Syntax.CommaStarEtc -> Typed.TypedTerm Syntax.StarEtc+starEtcStarComma x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarEtc"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starComma"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starNoDefault variant of hydra.python.syntax.StarEtc+starEtcStarNoDefault :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm Syntax.StarEtc+starEtcStarNoDefault x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarEtc"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starNoDefault"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starNoDefaultStarAnnotation variant of hydra.python.syntax.StarEtc+starEtcStarNoDefaultStarAnnotation :: Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc -> Typed.TypedTerm Syntax.StarEtc+starEtcStarNoDefaultStarAnnotation x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarEtc"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starNoDefaultStarAnnotation"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.StarExpression+starExpressionSimple :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.StarExpression+starExpressionSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the star variant of hydra.python.syntax.StarExpression+starExpressionStar :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.StarExpression+starExpressionStar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "star"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.StarNamedExpression+starNamedExpressionSimple :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.StarNamedExpression+starNamedExpressionSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarNamedExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the star variant of hydra.python.syntax.StarNamedExpression+starNamedExpressionStar :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.StarNamedExpression+starNamedExpressionStar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarNamedExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "star"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.StarNamedExpressions wrapper+starNamedExpressions :: Typed.TypedTerm [Syntax.StarNamedExpression] -> Typed.TypedTerm Syntax.StarNamedExpressions+starNamedExpressions x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarNamedExpressions"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the capture variant of hydra.python.syntax.StarPattern+starPatternCapture :: Typed.TypedTerm Syntax.PatternCaptureTarget -> Typed.TypedTerm Syntax.StarPattern+starPatternCapture x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "capture"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the wildcard variant of hydra.python.syntax.StarPattern+starPatternWildcard :: Typed.TypedTerm Syntax.StarPattern+starPatternWildcard =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarPattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wildcard"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the starred variant of hydra.python.syntax.StarTarget+starTargetStarred :: Typed.TypedTerm Syntax.StarTarget -> Typed.TypedTerm Syntax.StarTarget+starTargetStarred x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starred"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the unstarred variant of hydra.python.syntax.StarTarget+starTargetUnstarred :: Typed.TypedTerm Syntax.TargetWithStarAtom -> Typed.TypedTerm Syntax.StarTarget+starTargetUnstarred x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StarTarget"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unstarred"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.StarTargetsListSeq wrapper+starTargetsListSeq :: Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.StarTargetsListSeq+starTargetsListSeq x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarTargetsListSeq"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.python.syntax.StarTargetsTupleSeq wrapper+starTargetsTupleSeq :: Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.StarTargetsTupleSeq+starTargetsTupleSeq x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarTargetsTupleSeq"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.StarTypeParameter+starTypeParameter :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.StarExpression) -> Typed.TypedTerm Syntax.StarTypeParameter+starTypeParameter name default_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.StarTypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm default_)}]}))++-- | DSL accessor for the default field of hydra.python.syntax.StarTypeParameter+starTypeParameterDefault :: Typed.TypedTerm Syntax.StarTypeParameter -> Typed.TypedTerm (Maybe Syntax.StarExpression)+starTypeParameterDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.StarTypeParameter"),+        Core.projectionFieldName = (Core.Name "default")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.StarTypeParameter+starTypeParameterName :: Typed.TypedTerm Syntax.StarTypeParameter -> Typed.TypedTerm Syntax.Name+starTypeParameterName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.StarTypeParameter"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the default field of hydra.python.syntax.StarTypeParameter+starTypeParameterWithDefault :: Typed.TypedTerm Syntax.StarTypeParameter -> Typed.TypedTerm (Maybe Syntax.StarExpression) -> Typed.TypedTerm Syntax.StarTypeParameter+starTypeParameterWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.StarTypeParameter"),+      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.python.syntax.StarTypeParameter"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.StarTypeParameter+starTypeParameterWithName :: Typed.TypedTerm Syntax.StarTypeParameter -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.StarTypeParameter+starTypeParameterWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.StarTypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          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.python.syntax.StarTypeParameter"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.StarredExpression wrapper+starredExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.StarredExpression+starredExpression x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarredExpression"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the annotated variant of hydra.python.syntax.Statement+statementAnnotated :: Typed.TypedTerm Syntax.AnnotatedStatement -> Typed.TypedTerm Syntax.Statement+statementAnnotated x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Statement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotated"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the compound variant of hydra.python.syntax.Statement+statementCompound :: Typed.TypedTerm Syntax.CompoundStatement -> Typed.TypedTerm Syntax.Statement+statementCompound x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Statement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "compound"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.Statement+statementSimple :: Typed.TypedTerm [Syntax.SimpleStatement] -> Typed.TypedTerm Syntax.Statement+statementSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.Statement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.String+string :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Syntax.StringPrefix) -> Typed.TypedTerm Syntax.QuoteStyle -> Typed.TypedTerm Syntax.String_+string value prefix quoteStyle =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.String"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm value)},+        Core.Field {+          Core.fieldName = (Core.Name "prefix"),+          Core.fieldTerm = (Typed.unTypedTerm prefix)},+        Core.Field {+          Core.fieldName = (Core.Name "quoteStyle"),+          Core.fieldTerm = (Typed.unTypedTerm quoteStyle)}]}))++-- | DSL accessor for the prefix field of hydra.python.syntax.String+stringPrefix :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm (Maybe Syntax.StringPrefix)+stringPrefix x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+        Core.projectionFieldName = (Core.Name "prefix")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL injection for the bytes variant of hydra.python.syntax.StringPrefix+stringPrefixBytes :: Typed.TypedTerm Syntax.StringPrefix+stringPrefixBytes =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StringPrefix"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "bytes"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the raw variant of hydra.python.syntax.StringPrefix+stringPrefixRaw :: Typed.TypedTerm Syntax.StringPrefix+stringPrefixRaw =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StringPrefix"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "raw"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the rawBytes variant of hydra.python.syntax.StringPrefix+stringPrefixRawBytes :: Typed.TypedTerm Syntax.StringPrefix+stringPrefixRawBytes =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StringPrefix"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "rawBytes"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the unicode variant of hydra.python.syntax.StringPrefix+stringPrefixUnicode :: Typed.TypedTerm Syntax.StringPrefix+stringPrefixUnicode =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.StringPrefix"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unicode"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL accessor for the quoteStyle field of hydra.python.syntax.String+stringQuoteStyle :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm Syntax.QuoteStyle+stringQuoteStyle x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+        Core.projectionFieldName = (Core.Name "quoteStyle")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the value field of hydra.python.syntax.String+stringValue :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm String+stringValue x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+        Core.projectionFieldName = (Core.Name "value")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the prefix field of hydra.python.syntax.String+stringWithPrefix :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm (Maybe Syntax.StringPrefix) -> Typed.TypedTerm Syntax.String_+stringWithPrefix original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.String"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+              Core.projectionFieldName = (Core.Name "value")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "prefix"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "quoteStyle"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+              Core.projectionFieldName = (Core.Name "quoteStyle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the quoteStyle field of hydra.python.syntax.String+stringWithQuoteStyle :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm Syntax.QuoteStyle -> Typed.TypedTerm Syntax.String_+stringWithQuoteStyle original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.String"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+              Core.projectionFieldName = (Core.Name "value")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "prefix"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+              Core.projectionFieldName = (Core.Name "prefix")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "quoteStyle"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the value field of hydra.python.syntax.String+stringWithValue :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.String_+stringWithValue original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.String"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "prefix"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+              Core.projectionFieldName = (Core.Name "prefix")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "quoteStyle"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.String"),+              Core.projectionFieldName = (Core.Name "quoteStyle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the simple variant of hydra.python.syntax.SubjectExpression+subjectExpressionSimple :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.SubjectExpression+subjectExpressionSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SubjectExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the tuple variant of hydra.python.syntax.SubjectExpression+subjectExpressionTuple :: Typed.TypedTerm [Syntax.StarNamedExpression] -> Typed.TypedTerm Syntax.SubjectExpression+subjectExpressionTuple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SubjectExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "tuple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.Sum+sum :: Typed.TypedTerm (Maybe Syntax.SumLhs) -> Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.Sum+sum lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Sum"),+      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.python.syntax.Sum+sumLhs :: Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm (Maybe Syntax.SumLhs)+sumLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Sum"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.SumLhs+sumLhs2 :: Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm Syntax.SumOp -> Typed.TypedTerm Syntax.SumLhs+sumLhs2 operand operator =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SumLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Typed.unTypedTerm operand)},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Typed.unTypedTerm operator)}]}))++-- | DSL accessor for the operand field of hydra.python.syntax.SumLhs+sumLhsOperand :: Typed.TypedTerm Syntax.SumLhs -> Typed.TypedTerm Syntax.Sum+sumLhsOperand x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SumLhs"),+        Core.projectionFieldName = (Core.Name "operand")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the operator field of hydra.python.syntax.SumLhs+sumLhsOperator :: Typed.TypedTerm Syntax.SumLhs -> Typed.TypedTerm Syntax.SumOp+sumLhsOperator x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.SumLhs"),+        Core.projectionFieldName = (Core.Name "operator")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the operand field of hydra.python.syntax.SumLhs+sumLhsWithOperand :: Typed.TypedTerm Syntax.SumLhs -> Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm Syntax.SumLhs+sumLhsWithOperand original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SumLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SumLhs"),+              Core.projectionFieldName = (Core.Name "operator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the operator field of hydra.python.syntax.SumLhs+sumLhsWithOperator :: Typed.TypedTerm Syntax.SumLhs -> Typed.TypedTerm Syntax.SumOp -> Typed.TypedTerm Syntax.SumLhs+sumLhsWithOperator original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.SumLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.SumLhs"),+              Core.projectionFieldName = (Core.Name "operand")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the add variant of hydra.python.syntax.SumOp+sumOpAdd :: Typed.TypedTerm Syntax.SumOp+sumOpAdd =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SumOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "add"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the sub variant of hydra.python.syntax.SumOp+sumOpSub :: Typed.TypedTerm Syntax.SumOp+sumOpSub =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.SumOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "sub"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL accessor for the rhs field of hydra.python.syntax.Sum+sumRhs :: Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm Syntax.Term+sumRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Sum"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.Sum+sumWithLhs :: Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm (Maybe Syntax.SumLhs) -> Typed.TypedTerm Syntax.Sum+sumWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Sum"),+      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.python.syntax.Sum"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.Sum+sumWithRhs :: Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.Sum+sumWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Sum"),+      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.python.syntax.Sum"),+              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.python.syntax.TPrimaryAndArguments+tPrimaryAndArguments :: Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm (Maybe Syntax.Args) -> Typed.TypedTerm Syntax.TPrimaryAndArguments+tPrimaryAndArguments primary arguments =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndArguments"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm primary)},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Typed.unTypedTerm arguments)}]}))++-- | DSL accessor for the arguments field of hydra.python.syntax.TPrimaryAndArguments+tPrimaryAndArgumentsArguments :: Typed.TypedTerm Syntax.TPrimaryAndArguments -> Typed.TypedTerm (Maybe Syntax.Args)+tPrimaryAndArgumentsArguments x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndArguments"),+        Core.projectionFieldName = (Core.Name "arguments")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the primary field of hydra.python.syntax.TPrimaryAndArguments+tPrimaryAndArgumentsPrimary :: Typed.TypedTerm Syntax.TPrimaryAndArguments -> Typed.TypedTerm Syntax.TPrimary+tPrimaryAndArgumentsPrimary x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndArguments"),+        Core.projectionFieldName = (Core.Name "primary")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the arguments field of hydra.python.syntax.TPrimaryAndArguments+tPrimaryAndArgumentsWithArguments :: Typed.TypedTerm Syntax.TPrimaryAndArguments -> Typed.TypedTerm (Maybe Syntax.Args) -> Typed.TypedTerm Syntax.TPrimaryAndArguments+tPrimaryAndArgumentsWithArguments original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndArguments"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndArguments"),+              Core.projectionFieldName = (Core.Name "primary")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the primary field of hydra.python.syntax.TPrimaryAndArguments+tPrimaryAndArgumentsWithPrimary :: Typed.TypedTerm Syntax.TPrimaryAndArguments -> Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm Syntax.TPrimaryAndArguments+tPrimaryAndArgumentsWithPrimary original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndArguments"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "arguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndArguments"),+              Core.projectionFieldName = (Core.Name "arguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.TPrimaryAndGenexp+tPrimaryAndGenexp :: Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.TPrimaryAndGenexp+tPrimaryAndGenexp primary genexp =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndGenexp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm primary)},+        Core.Field {+          Core.fieldName = (Core.Name "genexp"),+          Core.fieldTerm = (Typed.unTypedTerm genexp)}]}))++-- | DSL accessor for the genexp field of hydra.python.syntax.TPrimaryAndGenexp+tPrimaryAndGenexpGenexp :: Typed.TypedTerm Syntax.TPrimaryAndGenexp -> Typed.TypedTerm Syntax.Genexp+tPrimaryAndGenexpGenexp x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndGenexp"),+        Core.projectionFieldName = (Core.Name "genexp")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the primary field of hydra.python.syntax.TPrimaryAndGenexp+tPrimaryAndGenexpPrimary :: Typed.TypedTerm Syntax.TPrimaryAndGenexp -> Typed.TypedTerm Syntax.TPrimary+tPrimaryAndGenexpPrimary x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndGenexp"),+        Core.projectionFieldName = (Core.Name "primary")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the genexp field of hydra.python.syntax.TPrimaryAndGenexp+tPrimaryAndGenexpWithGenexp :: Typed.TypedTerm Syntax.TPrimaryAndGenexp -> Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.TPrimaryAndGenexp+tPrimaryAndGenexpWithGenexp original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndGenexp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndGenexp"),+              Core.projectionFieldName = (Core.Name "primary")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "genexp"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the primary field of hydra.python.syntax.TPrimaryAndGenexp+tPrimaryAndGenexpWithPrimary :: Typed.TypedTerm Syntax.TPrimaryAndGenexp -> Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm Syntax.TPrimaryAndGenexp+tPrimaryAndGenexpWithPrimary original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndGenexp"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "genexp"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndGenexp"),+              Core.projectionFieldName = (Core.Name "genexp")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.TPrimaryAndName+tPrimaryAndName :: Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TPrimaryAndName+tPrimaryAndName primary name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm primary)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.python.syntax.TPrimaryAndName+tPrimaryAndNameName :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.Name+tPrimaryAndNameName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndName"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the primary field of hydra.python.syntax.TPrimaryAndName+tPrimaryAndNamePrimary :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.TPrimary+tPrimaryAndNamePrimary x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndName"),+        Core.projectionFieldName = (Core.Name "primary")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.python.syntax.TPrimaryAndName+tPrimaryAndNameWithName :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TPrimaryAndName+tPrimaryAndNameWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndName"),+              Core.projectionFieldName = (Core.Name "primary")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the primary field of hydra.python.syntax.TPrimaryAndName+tPrimaryAndNameWithPrimary :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm Syntax.TPrimaryAndName+tPrimaryAndNameWithPrimary original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          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.python.syntax.TPrimaryAndName"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.TPrimaryAndSlices+tPrimaryAndSlices :: Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm Syntax.Slices -> Typed.TypedTerm Syntax.TPrimaryAndSlices+tPrimaryAndSlices primary slices =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndSlices"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm primary)},+        Core.Field {+          Core.fieldName = (Core.Name "slices"),+          Core.fieldTerm = (Typed.unTypedTerm slices)}]}))++-- | DSL accessor for the primary field of hydra.python.syntax.TPrimaryAndSlices+tPrimaryAndSlicesPrimary :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.TPrimary+tPrimaryAndSlicesPrimary x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndSlices"),+        Core.projectionFieldName = (Core.Name "primary")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the slices field of hydra.python.syntax.TPrimaryAndSlices+tPrimaryAndSlicesSlices :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.Slices+tPrimaryAndSlicesSlices x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndSlices"),+        Core.projectionFieldName = (Core.Name "slices")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the primary field of hydra.python.syntax.TPrimaryAndSlices+tPrimaryAndSlicesWithPrimary :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm Syntax.TPrimaryAndSlices+tPrimaryAndSlicesWithPrimary original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndSlices"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "slices"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndSlices"),+              Core.projectionFieldName = (Core.Name "slices")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the slices field of hydra.python.syntax.TPrimaryAndSlices+tPrimaryAndSlicesWithSlices :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.Slices -> Typed.TypedTerm Syntax.TPrimaryAndSlices+tPrimaryAndSlicesWithSlices original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndSlices"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "primary"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TPrimaryAndSlices"),+              Core.projectionFieldName = (Core.Name "primary")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "slices"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the atom variant of hydra.python.syntax.TPrimary+tPrimaryAtom :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.TPrimary+tPrimaryAtom x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TPrimary"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "atom"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the primaryAndArguments variant of hydra.python.syntax.TPrimary+tPrimaryPrimaryAndArguments :: Typed.TypedTerm Syntax.TPrimaryAndArguments -> Typed.TypedTerm Syntax.TPrimary+tPrimaryPrimaryAndArguments x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TPrimary"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primaryAndArguments"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the primaryAndGenexp variant of hydra.python.syntax.TPrimary+tPrimaryPrimaryAndGenexp :: Typed.TypedTerm Syntax.TPrimaryAndGenexp -> Typed.TypedTerm Syntax.TPrimary+tPrimaryPrimaryAndGenexp x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TPrimary"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primaryAndGenexp"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the primaryAndName variant of hydra.python.syntax.TPrimary+tPrimaryPrimaryAndName :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.TPrimary+tPrimaryPrimaryAndName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TPrimary"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primaryAndName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the primaryAndSlices variant of hydra.python.syntax.TPrimary+tPrimaryPrimaryAndSlices :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.TPrimary+tPrimaryPrimaryAndSlices x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TPrimary"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primaryAndSlices"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the atom variant of hydra.python.syntax.TargetWithStarAtom+targetWithStarAtomAtom :: Typed.TypedTerm Syntax.StarAtom -> Typed.TypedTerm Syntax.TargetWithStarAtom+targetWithStarAtomAtom x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TargetWithStarAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "atom"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the project variant of hydra.python.syntax.TargetWithStarAtom+targetWithStarAtomProject :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.TargetWithStarAtom+targetWithStarAtomProject x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TargetWithStarAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "project"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the slices variant of hydra.python.syntax.TargetWithStarAtom+targetWithStarAtomSlices :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.TargetWithStarAtom+targetWithStarAtomSlices x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TargetWithStarAtom"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "slices"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.Term+term :: Typed.TypedTerm (Maybe Syntax.TermLhs) -> Typed.TypedTerm Syntax.Factor -> Typed.TypedTerm Syntax.Term+term lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Term"),+      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.python.syntax.Term+termLhs :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm (Maybe Syntax.TermLhs)+termLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Term"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.TermLhs+termLhs2 :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermOp -> Typed.TypedTerm Syntax.TermLhs+termLhs2 operand operator =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TermLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Typed.unTypedTerm operand)},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Typed.unTypedTerm operator)}]}))++-- | DSL accessor for the operand field of hydra.python.syntax.TermLhs+termLhsOperand :: Typed.TypedTerm Syntax.TermLhs -> Typed.TypedTerm Syntax.Term+termLhsOperand x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TermLhs"),+        Core.projectionFieldName = (Core.Name "operand")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the operator field of hydra.python.syntax.TermLhs+termLhsOperator :: Typed.TypedTerm Syntax.TermLhs -> Typed.TypedTerm Syntax.TermOp+termLhsOperator x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TermLhs"),+        Core.projectionFieldName = (Core.Name "operator")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the operand field of hydra.python.syntax.TermLhs+termLhsWithOperand :: Typed.TypedTerm Syntax.TermLhs -> Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermLhs+termLhsWithOperand original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TermLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TermLhs"),+              Core.projectionFieldName = (Core.Name "operator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the operator field of hydra.python.syntax.TermLhs+termLhsWithOperator :: Typed.TypedTerm Syntax.TermLhs -> Typed.TypedTerm Syntax.TermOp -> Typed.TypedTerm Syntax.TermLhs+termLhsWithOperator original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TermLhs"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "operand"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TermLhs"),+              Core.projectionFieldName = (Core.Name "operand")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "operator"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the div variant of hydra.python.syntax.TermOp+termOpDiv :: Typed.TypedTerm Syntax.TermOp+termOpDiv =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TermOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "div"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the floordiv variant of hydra.python.syntax.TermOp+termOpFloordiv :: Typed.TypedTerm Syntax.TermOp+termOpFloordiv =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TermOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "floordiv"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the matmul variant of hydra.python.syntax.TermOp+termOpMatmul :: Typed.TypedTerm Syntax.TermOp+termOpMatmul =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TermOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "matmul"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the mod variant of hydra.python.syntax.TermOp+termOpMod :: Typed.TypedTerm Syntax.TermOp+termOpMod =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TermOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mod"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the mul variant of hydra.python.syntax.TermOp+termOpMul :: Typed.TypedTerm Syntax.TermOp+termOpMul =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TermOp"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mul"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL accessor for the rhs field of hydra.python.syntax.Term+termRhs :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.Factor+termRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.Term"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.Term+termWithLhs :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm (Maybe Syntax.TermLhs) -> Typed.TypedTerm Syntax.Term+termWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Term"),+      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.python.syntax.Term"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.Term+termWithRhs :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.Factor -> Typed.TypedTerm Syntax.Term+termWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.Term"),+      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.python.syntax.Term"),+              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.python.syntax.TryExceptStarStatement+tryExceptStarStatement :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm [Syntax.ExceptStarBlock] -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryExceptStarStatement+tryExceptStarStatement body excepts else_ finally =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Typed.unTypedTerm excepts)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm else_)},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Typed.unTypedTerm finally)}]}))++-- | DSL accessor for the body field of hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementBody :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm Syntax.Block+tryExceptStarStatementBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the else field of hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementElse :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm (Maybe Syntax.Block)+tryExceptStarStatementElse x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+        Core.projectionFieldName = (Core.Name "else")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the excepts field of hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementExcepts :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm [Syntax.ExceptStarBlock]+tryExceptStarStatementExcepts x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+        Core.projectionFieldName = (Core.Name "excepts")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the finally field of hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementFinally :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm (Maybe Syntax.Block)+tryExceptStarStatementFinally x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+        Core.projectionFieldName = (Core.Name "finally")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementWithBody :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryExceptStarStatement+tryExceptStarStatementWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "excepts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "finally")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the else field of hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementWithElse :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryExceptStarStatement+tryExceptStarStatementWithElse original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+      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.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "excepts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "finally")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the excepts field of hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementWithExcepts :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm [Syntax.ExceptStarBlock] -> Typed.TypedTerm Syntax.TryExceptStarStatement+tryExceptStarStatementWithExcepts original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+      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.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "finally")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the finally field of hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementWithFinally :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryExceptStarStatement+tryExceptStarStatementWithFinally original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+      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.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "excepts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStarStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.TryExceptStatement+tryExceptStatement :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm [Syntax.ExceptBlock] -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryExceptStatement+tryExceptStatement body excepts else_ finally =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Typed.unTypedTerm excepts)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm else_)},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Typed.unTypedTerm finally)}]}))++-- | DSL accessor for the body field of hydra.python.syntax.TryExceptStatement+tryExceptStatementBody :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm Syntax.Block+tryExceptStatementBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the else field of hydra.python.syntax.TryExceptStatement+tryExceptStatementElse :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm (Maybe Syntax.Block)+tryExceptStatementElse x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+        Core.projectionFieldName = (Core.Name "else")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the excepts field of hydra.python.syntax.TryExceptStatement+tryExceptStatementExcepts :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm [Syntax.ExceptBlock]+tryExceptStatementExcepts x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+        Core.projectionFieldName = (Core.Name "excepts")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the finally field of hydra.python.syntax.TryExceptStatement+tryExceptStatementFinally :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm (Maybe Syntax.Block)+tryExceptStatementFinally x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+        Core.projectionFieldName = (Core.Name "finally")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.python.syntax.TryExceptStatement+tryExceptStatementWithBody :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryExceptStatement+tryExceptStatementWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "excepts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "finally")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the else field of hydra.python.syntax.TryExceptStatement+tryExceptStatementWithElse :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryExceptStatement+tryExceptStatementWithElse original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+      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.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "excepts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "finally")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the excepts field of hydra.python.syntax.TryExceptStatement+tryExceptStatementWithExcepts :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm [Syntax.ExceptBlock] -> Typed.TypedTerm Syntax.TryExceptStatement+tryExceptStatementWithExcepts original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+      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.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "finally")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the finally field of hydra.python.syntax.TryExceptStatement+tryExceptStatementWithFinally :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryExceptStatement+tryExceptStatementWithFinally original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+      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.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "excepts"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "excepts")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryExceptStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.TryFinallyStatement+tryFinallyStatement :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryFinallyStatement+tryFinallyStatement body finally =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryFinallyStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Typed.unTypedTerm finally)}]}))++-- | DSL accessor for the body field of hydra.python.syntax.TryFinallyStatement+tryFinallyStatementBody :: Typed.TypedTerm Syntax.TryFinallyStatement -> Typed.TypedTerm Syntax.Block+tryFinallyStatementBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryFinallyStatement"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the finally field of hydra.python.syntax.TryFinallyStatement+tryFinallyStatementFinally :: Typed.TypedTerm Syntax.TryFinallyStatement -> Typed.TypedTerm Syntax.Block+tryFinallyStatementFinally x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryFinallyStatement"),+        Core.projectionFieldName = (Core.Name "finally")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.python.syntax.TryFinallyStatement+tryFinallyStatementWithBody :: Typed.TypedTerm Syntax.TryFinallyStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryFinallyStatement+tryFinallyStatementWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryFinallyStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TryFinallyStatement"),+              Core.projectionFieldName = (Core.Name "finally")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the finally field of hydra.python.syntax.TryFinallyStatement+tryFinallyStatementWithFinally :: Typed.TypedTerm Syntax.TryFinallyStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryFinallyStatement+tryFinallyStatementWithFinally original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TryFinallyStatement"),+      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.python.syntax.TryFinallyStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "finally"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the except variant of hydra.python.syntax.TryStatement+tryStatementExcept :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm Syntax.TryStatement+tryStatementExcept x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TryStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "except"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the exceptStar variant of hydra.python.syntax.TryStatement+tryStatementExceptStar :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm Syntax.TryStatement+tryStatementExceptStar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TryStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "exceptStar"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the finally variant of hydra.python.syntax.TryStatement+tryStatementFinally :: Typed.TypedTerm Syntax.TryFinallyStatement -> Typed.TypedTerm Syntax.TryStatement+tryStatementFinally x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TryStatement"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "finally"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.Tuple wrapper+tuple :: Typed.TypedTerm [Syntax.StarNamedExpression] -> Typed.TypedTerm Syntax.Tuple+tuple x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Tuple"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.TypeAlias+typeAlias :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeAlias+typeAlias name typeParams expression =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Typed.unTypedTerm typeParams)},+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)}]}))++-- | DSL accessor for the expression field of hydra.python.syntax.TypeAlias+typeAliasExpression :: Typed.TypedTerm Syntax.TypeAlias -> Typed.TypedTerm Syntax.Expression+typeAliasExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.python.syntax.TypeAlias+typeAliasName :: Typed.TypedTerm Syntax.TypeAlias -> Typed.TypedTerm Syntax.Name+typeAliasName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeParams field of hydra.python.syntax.TypeAlias+typeAliasTypeParams :: Typed.TypedTerm Syntax.TypeAlias -> Typed.TypedTerm [Syntax.TypeParameter]+typeAliasTypeParams x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+        Core.projectionFieldName = (Core.Name "typeParams")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expression field of hydra.python.syntax.TypeAlias+typeAliasWithExpression :: Typed.TypedTerm Syntax.TypeAlias -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeAlias+typeAliasWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+      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.python.syntax.TypeAlias"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.python.syntax.TypeAlias+typeAliasWithName :: Typed.TypedTerm Syntax.TypeAlias -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TypeAlias+typeAliasWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeParams field of hydra.python.syntax.TypeAlias+typeAliasWithTypeParams :: Typed.TypedTerm Syntax.TypeAlias -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.TypeAlias+typeAliasWithTypeParams original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+      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.python.syntax.TypeAlias"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypeAlias"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.python.syntax.TypeComment wrapper+typeComment :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.TypeComment+typeComment x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.TypeComment"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL injection for the doubleStarredExpression variant of hydra.python.syntax.TypeExpression+typeExpressionDoubleStarredExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeExpression+typeExpressionDoubleStarredExpression x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TypeExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "doubleStarredExpression"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the expression variant of hydra.python.syntax.TypeExpression+typeExpressionExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeExpression+typeExpressionExpression x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TypeExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "expression"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the starredExpression variant of hydra.python.syntax.TypeExpression+typeExpressionStarredExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeExpression+typeExpressionStarredExpression x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TypeExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "starredExpression"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the doubleStar variant of hydra.python.syntax.TypeParameter+typeParameterDoubleStar :: Typed.TypedTerm Syntax.DoubleStarTypeParameter -> Typed.TypedTerm Syntax.TypeParameter+typeParameterDoubleStar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TypeParameter"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "doubleStar"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.TypeParameter+typeParameterSimple :: Typed.TypedTerm Syntax.SimpleTypeParameter -> Typed.TypedTerm Syntax.TypeParameter+typeParameterSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TypeParameter"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the star variant of hydra.python.syntax.TypeParameter+typeParameterStar :: Typed.TypedTerm Syntax.StarTypeParameter -> Typed.TypedTerm Syntax.TypeParameter+typeParameterStar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.TypeParameter"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "star"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.python.syntax.TypedAssignment+typedAssignment :: Typed.TypedTerm Syntax.SingleTarget -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.AnnotatedRhs) -> Typed.TypedTerm Syntax.TypedAssignment+typedAssignment lhs type_ rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (Typed.unTypedTerm lhs)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.python.syntax.TypedAssignment+typedAssignmentLhs :: Typed.TypedTerm Syntax.TypedAssignment -> Typed.TypedTerm Syntax.SingleTarget+typedAssignmentLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.python.syntax.TypedAssignment+typedAssignmentRhs :: Typed.TypedTerm Syntax.TypedAssignment -> Typed.TypedTerm (Maybe Syntax.AnnotatedRhs)+typedAssignmentRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the type field of hydra.python.syntax.TypedAssignment+typedAssignmentType :: Typed.TypedTerm Syntax.TypedAssignment -> Typed.TypedTerm Syntax.Expression+typedAssignmentType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.python.syntax.TypedAssignment+typedAssignmentWithLhs :: Typed.TypedTerm Syntax.TypedAssignment -> Typed.TypedTerm Syntax.SingleTarget -> Typed.TypedTerm Syntax.TypedAssignment+typedAssignmentWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+              Core.projectionFieldName = (Core.Name "type")})),+            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.python.syntax.TypedAssignment"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.python.syntax.TypedAssignment+typedAssignmentWithRhs :: Typed.TypedTerm Syntax.TypedAssignment -> Typed.TypedTerm (Maybe Syntax.AnnotatedRhs) -> Typed.TypedTerm Syntax.TypedAssignment+typedAssignmentWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+      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.python.syntax.TypedAssignment"),+              Core.projectionFieldName = (Core.Name "lhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the type field of hydra.python.syntax.TypedAssignment+typedAssignmentWithType :: Typed.TypedTerm Syntax.TypedAssignment -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypedAssignment+typedAssignmentWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.TypedAssignment"),+      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.python.syntax.TypedAssignment"),+              Core.projectionFieldName = (Core.Name "lhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          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.python.syntax.TypedAssignment"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL accessor for the body of hydra.python.syntax.Annotation+unAnnotation :: Typed.TypedTerm Syntax.Annotation -> Typed.TypedTerm Syntax.Expression+unAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Annotation")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Attribute+unAttribute :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm [Syntax.Name]+unAttribute x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Attribute")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.CapturePattern+unCapturePattern :: Typed.TypedTerm Syntax.CapturePattern -> Typed.TypedTerm Syntax.PatternCaptureTarget+unCapturePattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.CapturePattern")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Conjunction+unConjunction :: Typed.TypedTerm Syntax.Conjunction -> Typed.TypedTerm [Syntax.Inversion]+unConjunction x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Conjunction")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Decorators+unDecorators :: Typed.TypedTerm Syntax.Decorators -> Typed.TypedTerm [Syntax.NamedExpression]+unDecorators x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Decorators")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Default+unDefault :: Typed.TypedTerm Syntax.Default -> Typed.TypedTerm Syntax.Expression+unDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Default")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.DelStatement+unDelStatement :: Typed.TypedTerm Syntax.DelStatement -> Typed.TypedTerm Syntax.DelTargets+unDelStatement x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.DelStatement")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.DelTargets+unDelTargets :: Typed.TypedTerm Syntax.DelTargets -> Typed.TypedTerm [Syntax.DelTarget]+unDelTargets x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.DelTargets")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Dict+unDict :: Typed.TypedTerm Syntax.Dict -> Typed.TypedTerm [Syntax.DoubleStarredKvpair]+unDict x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Dict")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Disjunction+unDisjunction :: Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm [Syntax.Conjunction]+unDisjunction x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Disjunction")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.DottedName+unDottedName :: Typed.TypedTerm Syntax.DottedName -> Typed.TypedTerm [Syntax.Name]+unDottedName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.DottedName")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.DoubleStarPattern+unDoubleStarPattern :: Typed.TypedTerm Syntax.DoubleStarPattern -> Typed.TypedTerm Syntax.PatternCaptureTarget+unDoubleStarPattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.DoubleStarPattern")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Eval+unEval :: Typed.TypedTerm Syntax.Eval -> Typed.TypedTerm [Syntax.Expression]+unEval x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Eval")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.File+unFile :: Typed.TypedTerm Syntax.File -> Typed.TypedTerm [Syntax.Statement]+unFile x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.File")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.ForIfClauses+unForIfClauses :: Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm [Syntax.ForIfClause]+unForIfClauses x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.ForIfClauses")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.FuncTypeComment+unFuncTypeComment :: Typed.TypedTerm Syntax.FuncTypeComment -> Typed.TypedTerm Syntax.TypeComment+unFuncTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.FuncTypeComment")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.GroupPattern+unGroupPattern :: Typed.TypedTerm Syntax.GroupPattern -> Typed.TypedTerm Syntax.Pattern+unGroupPattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.GroupPattern")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Guard+unGuard :: Typed.TypedTerm Syntax.Guard -> Typed.TypedTerm Syntax.NamedExpression+unGuard x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Guard")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.ImaginaryNumber+unImaginaryNumber :: Typed.TypedTerm Syntax.ImaginaryNumber -> Typed.TypedTerm Double+unImaginaryNumber x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.ImaginaryNumber")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.ImportName+unImportName :: Typed.TypedTerm Syntax.ImportName -> Typed.TypedTerm [Syntax.DottedAsName]+unImportName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.ImportName")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Interactive+unInteractive :: Typed.TypedTerm Syntax.Interactive -> Typed.TypedTerm Syntax.Statement+unInteractive x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Interactive")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.ItemsPattern+unItemsPattern :: Typed.TypedTerm Syntax.ItemsPattern -> Typed.TypedTerm [Syntax.KeyValuePattern]+unItemsPattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.ItemsPattern")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.KeywordPatterns+unKeywordPatterns :: Typed.TypedTerm Syntax.KeywordPatterns -> Typed.TypedTerm [Syntax.KeywordPattern]+unKeywordPatterns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.KeywordPatterns")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Keywords+unKeywords :: Typed.TypedTerm Syntax.Keywords -> Typed.TypedTerm Syntax.ParamNoDefault+unKeywords x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Keywords")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.LambdaKwds+unLambdaKwds :: Typed.TypedTerm Syntax.LambdaKwds -> Typed.TypedTerm Syntax.LambdaParamNoDefault+unLambdaKwds x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.LambdaKwds")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.LambdaParamNoDefault+unLambdaParamNoDefault :: Typed.TypedTerm Syntax.LambdaParamNoDefault -> Typed.TypedTerm Syntax.Name+unLambdaParamNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.LambdaParamNoDefault")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.List+unList :: Typed.TypedTerm Syntax.List -> Typed.TypedTerm [Syntax.StarNamedExpression]+unList x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.List")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.MaybeSequencePattern+unMaybeSequencePattern :: Typed.TypedTerm Syntax.MaybeSequencePattern -> Typed.TypedTerm [Syntax.MaybeStarPattern]+unMaybeSequencePattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.MaybeSequencePattern")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Module+unModule :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [[Syntax.Statement]]+unModule x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Module")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Name+unName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm String+unName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Name")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.NameOrAttribute+unNameOrAttribute :: Typed.TypedTerm Syntax.NameOrAttribute -> Typed.TypedTerm [Syntax.Name]+unNameOrAttribute x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.NameOrAttribute")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.OrPattern+unOrPattern :: Typed.TypedTerm Syntax.OrPattern -> Typed.TypedTerm [Syntax.ClosedPattern]+unOrPattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.OrPattern")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.PatternCaptureTarget+unPatternCaptureTarget :: Typed.TypedTerm Syntax.PatternCaptureTarget -> Typed.TypedTerm Syntax.Name+unPatternCaptureTarget x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.PatternCaptureTarget")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.PositionalPatterns+unPositionalPatterns :: Typed.TypedTerm Syntax.PositionalPatterns -> Typed.TypedTerm [Syntax.Pattern]+unPositionalPatterns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.PositionalPatterns")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.RaiseStatement+unRaiseStatement :: Typed.TypedTerm Syntax.RaiseStatement -> Typed.TypedTerm (Maybe Syntax.RaiseExpression)+unRaiseStatement x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.RaiseStatement")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.ReturnStatement+unReturnStatement :: Typed.TypedTerm Syntax.ReturnStatement -> Typed.TypedTerm [Syntax.StarExpression]+unReturnStatement x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.ReturnStatement")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Set+unSet :: Typed.TypedTerm Syntax.Set -> Typed.TypedTerm [Syntax.StarNamedExpression]+unSet x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Set")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.SlashNoDefault+unSlashNoDefault :: Typed.TypedTerm Syntax.SlashNoDefault -> Typed.TypedTerm [Syntax.ParamNoDefault]+unSlashNoDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.SlashNoDefault")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.StarAnnotation+unStarAnnotation :: Typed.TypedTerm Syntax.StarAnnotation -> Typed.TypedTerm Syntax.StarExpression+unStarAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.StarAnnotation")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.StarNamedExpressions+unStarNamedExpressions :: Typed.TypedTerm Syntax.StarNamedExpressions -> Typed.TypedTerm [Syntax.StarNamedExpression]+unStarNamedExpressions x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.StarNamedExpressions")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.StarTargetsListSeq+unStarTargetsListSeq :: Typed.TypedTerm Syntax.StarTargetsListSeq -> Typed.TypedTerm [Syntax.StarTarget]+unStarTargetsListSeq x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.StarTargetsListSeq")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.StarTargetsTupleSeq+unStarTargetsTupleSeq :: Typed.TypedTerm Syntax.StarTargetsTupleSeq -> Typed.TypedTerm [Syntax.StarTarget]+unStarTargetsTupleSeq x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.StarTargetsTupleSeq")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.StarredExpression+unStarredExpression :: Typed.TypedTerm Syntax.StarredExpression -> Typed.TypedTerm Syntax.Expression+unStarredExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.StarredExpression")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.Tuple+unTuple :: Typed.TypedTerm Syntax.Tuple -> Typed.TypedTerm [Syntax.StarNamedExpression]+unTuple x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.Tuple")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.TypeComment+unTypeComment :: Typed.TypedTerm Syntax.TypeComment -> Typed.TypedTerm String+unTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.TypeComment")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.ValuePattern+unValuePattern :: Typed.TypedTerm Syntax.ValuePattern -> Typed.TypedTerm Syntax.Attribute+unValuePattern x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.ValuePattern")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.python.syntax.YieldStatement+unYieldStatement :: Typed.TypedTerm Syntax.YieldStatement -> Typed.TypedTerm Syntax.YieldExpression+unYieldStatement x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.python.syntax.YieldStatement")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.UntypedAssignment+untypedAssignment :: Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.AnnotatedRhs -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.UntypedAssignment+untypedAssignment targets rhs typeComment =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Typed.unTypedTerm targets)},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm rhs)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm typeComment)}]}))++-- | DSL accessor for the rhs field of hydra.python.syntax.UntypedAssignment+untypedAssignmentRhs :: Typed.TypedTerm Syntax.UntypedAssignment -> Typed.TypedTerm Syntax.AnnotatedRhs+untypedAssignmentRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the targets field of hydra.python.syntax.UntypedAssignment+untypedAssignmentTargets :: Typed.TypedTerm Syntax.UntypedAssignment -> Typed.TypedTerm [Syntax.StarTarget]+untypedAssignmentTargets x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+        Core.projectionFieldName = (Core.Name "targets")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeComment field of hydra.python.syntax.UntypedAssignment+untypedAssignmentTypeComment :: Typed.TypedTerm Syntax.UntypedAssignment -> Typed.TypedTerm (Maybe Syntax.TypeComment)+untypedAssignmentTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+        Core.projectionFieldName = (Core.Name "typeComment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the rhs field of hydra.python.syntax.UntypedAssignment+untypedAssignmentWithRhs :: Typed.TypedTerm Syntax.UntypedAssignment -> Typed.TypedTerm Syntax.AnnotatedRhs -> Typed.TypedTerm Syntax.UntypedAssignment+untypedAssignmentWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+              Core.projectionFieldName = (Core.Name "targets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the targets field of hydra.python.syntax.UntypedAssignment+untypedAssignmentWithTargets :: Typed.TypedTerm Syntax.UntypedAssignment -> Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.UntypedAssignment+untypedAssignmentWithTargets original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          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.python.syntax.UntypedAssignment"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeComment field of hydra.python.syntax.UntypedAssignment+untypedAssignmentWithTypeComment :: Typed.TypedTerm Syntax.UntypedAssignment -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.UntypedAssignment+untypedAssignmentWithTypeComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "targets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.UntypedAssignment"),+              Core.projectionFieldName = (Core.Name "targets")})),+            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.python.syntax.UntypedAssignment"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.python.syntax.ValuePattern wrapper+valuePattern :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm Syntax.ValuePattern+valuePattern x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ValuePattern"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.python.syntax.WhileStatement+whileStatement :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.WhileStatement+whileStatement condition body else_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "condition"),+          Core.fieldTerm = (Typed.unTypedTerm condition)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm else_)}]}))++-- | DSL accessor for the body field of hydra.python.syntax.WhileStatement+whileStatementBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Block+whileStatementBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the condition field of hydra.python.syntax.WhileStatement+whileStatementCondition :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.NamedExpression+whileStatementCondition x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+        Core.projectionFieldName = (Core.Name "condition")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the else field of hydra.python.syntax.WhileStatement+whileStatementElse :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm (Maybe Syntax.Block)+whileStatementElse x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+        Core.projectionFieldName = (Core.Name "else")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.python.syntax.WhileStatement+whileStatementWithBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.WhileStatement+whileStatementWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "condition"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+              Core.projectionFieldName = (Core.Name "condition")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the condition field of hydra.python.syntax.WhileStatement+whileStatementWithCondition :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.WhileStatement+whileStatementWithCondition original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "condition"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+              Core.projectionFieldName = (Core.Name "else")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the else field of hydra.python.syntax.WhileStatement+whileStatementWithElse :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.WhileStatement+whileStatementWithElse original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "condition"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WhileStatement"),+              Core.projectionFieldName = (Core.Name "condition")})),+            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.python.syntax.WhileStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "else"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.python.syntax.WithItem+withItem :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.StarTarget) -> Typed.TypedTerm Syntax.WithItem+withItem expression as =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WithItem"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm expression)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm as)}]}))++-- | DSL accessor for the as field of hydra.python.syntax.WithItem+withItemAs :: Typed.TypedTerm Syntax.WithItem -> Typed.TypedTerm (Maybe Syntax.StarTarget)+withItemAs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithItem"),+        Core.projectionFieldName = (Core.Name "as")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expression field of hydra.python.syntax.WithItem+withItemExpression :: Typed.TypedTerm Syntax.WithItem -> Typed.TypedTerm Syntax.Expression+withItemExpression x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithItem"),+        Core.projectionFieldName = (Core.Name "expression")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the as field of hydra.python.syntax.WithItem+withItemWithAs :: Typed.TypedTerm Syntax.WithItem -> Typed.TypedTerm (Maybe Syntax.StarTarget) -> Typed.TypedTerm Syntax.WithItem+withItemWithAs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WithItem"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithItem"),+              Core.projectionFieldName = (Core.Name "expression")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the expression field of hydra.python.syntax.WithItem+withItemWithExpression :: Typed.TypedTerm Syntax.WithItem -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.WithItem+withItemWithExpression original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WithItem"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expression"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "as"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithItem"),+              Core.projectionFieldName = (Core.Name "as")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.python.syntax.WithStatement+withStatement :: Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.WithItem] -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.WithStatement+withStatement async items typeComment body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Typed.unTypedTerm async)},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Typed.unTypedTerm items)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Typed.unTypedTerm typeComment)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the async field of hydra.python.syntax.WithStatement+withStatementAsync :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm Bool+withStatementAsync x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+        Core.projectionFieldName = (Core.Name "async")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body field of hydra.python.syntax.WithStatement+withStatementBody :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm Syntax.Block+withStatementBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the items field of hydra.python.syntax.WithStatement+withStatementItems :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm [Syntax.WithItem]+withStatementItems x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+        Core.projectionFieldName = (Core.Name "items")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typeComment field of hydra.python.syntax.WithStatement+withStatementTypeComment :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm (Maybe Syntax.TypeComment)+withStatementTypeComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+        Core.projectionFieldName = (Core.Name "typeComment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the async field of hydra.python.syntax.WithStatement+withStatementWithAsync :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.WithStatement+withStatementWithAsync original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "items")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            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.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the body field of hydra.python.syntax.WithStatement+withStatementWithBody :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.WithStatement+withStatementWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "items")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the items field of hydra.python.syntax.WithStatement+withStatementWithItems :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm [Syntax.WithItem] -> Typed.TypedTerm Syntax.WithStatement+withStatementWithItems original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "typeComment")})),+            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.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typeComment field of hydra.python.syntax.WithStatement+withStatementWithTypeComment :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.WithStatement+withStatementWithTypeComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "async"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "async")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "items"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "items")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeComment"),+          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.python.syntax.WithStatement"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the from variant of hydra.python.syntax.YieldExpression+yieldExpressionFrom :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.YieldExpression+yieldExpressionFrom x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.YieldExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "from"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the simple variant of hydra.python.syntax.YieldExpression+yieldExpressionSimple :: Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm Syntax.YieldExpression+yieldExpressionSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.python.syntax.YieldExpression"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for the hydra.python.syntax.YieldStatement wrapper+yieldStatement :: Typed.TypedTerm Syntax.YieldExpression -> Typed.TypedTerm Syntax.YieldStatement+yieldStatement x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.YieldStatement"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))