hydra-scala (empty) → 0.17.0
raw patch · 10 files changed
+17333/−0 lines, 10 filesdep +basedep +containersdep +hydra-jvm
Dependencies added: base, containers, hydra-jvm, scientific
Files
- CHANGELOG.md +1372/−0
- LICENSE +201/−0
- NOTICE +3/−0
- hydra-scala.cabal +45/−0
- src/main/haskell/Hydra/Dsl/Scala/Syntax.hs +11736/−0
- src/main/haskell/Hydra/Scala/Coder.hs +955/−0
- src/main/haskell/Hydra/Scala/Language.hs +226/−0
- src/main/haskell/Hydra/Scala/Serde.hs +435/−0
- src/main/haskell/Hydra/Scala/Syntax.hs +2128/−0
- src/main/haskell/Hydra/Scala/Utils.hs +232/−0
+ CHANGELOG.md view
@@ -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.
+ LICENSE view
@@ -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.
+ NOTICE view
@@ -0,0 +1,3 @@+Hydra+Copyright 2021-2026 The Hydra authors+https://github.com/CategoricalData/hydra
+ hydra-scala.cabal view
@@ -0,0 +1,45 @@+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.39.1.+--+-- see: https://github.com/sol/hpack++name: hydra-scala+version: 0.17.0+synopsis: Hydra's Scala coder: emit Scala source from Hydra modules+description: Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". Scala support for Hydra+category: Data+homepage: https://github.com/CategoricalData/hydra#readme+bug-reports: https://github.com/CategoricalData/hydra/issues+author: Joshua Shinavier <josh@fortytwo.net>+maintainer: Joshua Shinavier <josh@fortytwo.net>+license: Apache-2.0+license-file: LICENSE+build-type: Simple+extra-source-files:+ LICENSE+ NOTICE+ CHANGELOG.md++source-repository head+ type: git+ location: https://github.com/CategoricalData/hydra++library+ exposed-modules:+ Hydra.Dsl.Scala.Syntax+ Hydra.Scala.Coder+ Hydra.Scala.Language+ Hydra.Scala.Serde+ Hydra.Scala.Syntax+ Hydra.Scala.Utils+ other-modules:+ Paths_hydra_scala+ hs-source-dirs:+ src/main/haskell+ build-depends:+ base >=4.19.0 && <4.22+ , containers >=0.6.7 && <0.8+ , hydra-jvm ==0.17.0+ , scientific >=0.3.7 && <0.4+ default-language: Haskell2010
+ src/main/haskell/Hydra/Dsl/Scala/Syntax.hs view
@@ -0,0 +1,11736 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.scala.syntax++module Hydra.Dsl.Scala.Syntax where++import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Scala.Syntax as Syntax+import qualified Hydra.Typed as Typed+import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Int as I++-- | DSL constructor for hydra.scala.syntax.AlternativePat+alternativePat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.AlternativePat+alternativePat lhs rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.AlternativePat+alternativePatLhs :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat+alternativePatLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.AlternativePat+alternativePatRhs :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat+alternativePatRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.AlternativePat+alternativePatWithLhs :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.AlternativePat+alternativePatWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.AlternativePat+alternativePatWithRhs :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.AlternativePat+alternativePatWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AlternativePat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.AndType+andType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AndType+andType lhs rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AndType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.AndType+andTypeLhs :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type+andTypeLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AndType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.AndType+andTypeRhs :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type+andTypeRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AndType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.AndType+andTypeWithLhs :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AndType+andTypeWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AndType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AndType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.AndType+andTypeWithRhs :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AndType+andTypeWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AndType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AndType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.AnnotMod+annotMod :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.AnnotMod+annotMod init =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotMod"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Typed.unTypedTerm init)}]}))++-- | DSL accessor for the init field of hydra.scala.syntax.AnnotMod+annotModInit :: Typed.TypedTerm Syntax.AnnotMod -> Typed.TypedTerm Syntax.Init+annotModInit x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotMod"),+ Core.projectionFieldName = (Core.Name "init")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the init field of hydra.scala.syntax.AnnotMod+annotModWithInit :: Typed.TypedTerm Syntax.AnnotMod -> Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.AnnotMod+annotModWithInit original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotMod"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.AnnotateData+annotateData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.AnnotMod] -> Typed.TypedTerm Syntax.AnnotateData+annotateData expr annots =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)},+ Core.Field {+ Core.fieldName = (Core.Name "annots"),+ Core.fieldTerm = (Typed.unTypedTerm annots)}]}))++-- | DSL accessor for the annots field of hydra.scala.syntax.AnnotateData+annotateDataAnnots :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm [Syntax.AnnotMod]+annotateDataAnnots x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),+ Core.projectionFieldName = (Core.Name "annots")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expr field of hydra.scala.syntax.AnnotateData+annotateDataExpr :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm Syntax.Data+annotateDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the annots field of hydra.scala.syntax.AnnotateData+annotateDataWithAnnots :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm [Syntax.AnnotMod] -> Typed.TypedTerm Syntax.AnnotateData+annotateDataWithAnnots original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "annots"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the expr field of hydra.scala.syntax.AnnotateData+annotateDataWithExpr :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AnnotateData+annotateDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "annots"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateData"),+ Core.projectionFieldName = (Core.Name "annots")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.AnnotateType+annotateType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.AnnotMod] -> Typed.TypedTerm Syntax.AnnotateType+annotateType tpe annots =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)},+ Core.Field {+ Core.fieldName = (Core.Name "annots"),+ Core.fieldTerm = (Typed.unTypedTerm annots)}]}))++-- | DSL accessor for the annots field of hydra.scala.syntax.AnnotateType+annotateTypeAnnots :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm [Syntax.AnnotMod]+annotateTypeAnnots x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),+ Core.projectionFieldName = (Core.Name "annots")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.AnnotateType+annotateTypeTpe :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm Syntax.Type+annotateTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the annots field of hydra.scala.syntax.AnnotateType+annotateTypeWithAnnots :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm [Syntax.AnnotMod] -> Typed.TypedTerm Syntax.AnnotateType+annotateTypeWithAnnots original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "annots"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.AnnotateType+annotateTypeWithTpe :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AnnotateType+annotateTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "annots"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AnnotateType"),+ Core.projectionFieldName = (Core.Name "annots")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.scala.syntax.AnonymousData wrapper+anonymousData :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.AnonymousData+anonymousData x =+ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+ Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.AnonymousData"),+ Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for the hydra.scala.syntax.AnonymousNameType wrapper+anonymousNameType :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.AnonymousNameType+anonymousNameType x =+ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+ Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.AnonymousNameType"),+ Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.scala.syntax.ApplyData+applyData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyData+applyData fun args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Typed.unTypedTerm fun)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.ApplyData+applyDataArgs :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm [Syntax.Data]+applyDataArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the fun field of hydra.scala.syntax.ApplyData+applyDataFun :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm Syntax.Data+applyDataFun x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),+ Core.projectionFieldName = (Core.Name "fun")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.ApplyData+applyDataWithArgs :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyData+applyDataWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),+ Core.projectionFieldName = (Core.Name "fun")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the fun field of hydra.scala.syntax.ApplyData+applyDataWithFun :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyData+applyDataWithFun original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ApplyInfixData+applyInfixData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyInfixData+applyInfixData lhs op targs args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm op)},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Typed.unTypedTerm targs)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.ApplyInfixData+applyInfixDataArgs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm [Syntax.Data]+applyInfixDataArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.ApplyInfixData+applyInfixDataLhs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm Syntax.Data+applyInfixDataLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the op field of hydra.scala.syntax.ApplyInfixData+applyInfixDataOp :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm Syntax.NameData+applyInfixDataOp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the targs field of hydra.scala.syntax.ApplyInfixData+applyInfixDataTargs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm [Syntax.Type]+applyInfixDataTargs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.ApplyInfixData+applyInfixDataWithArgs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyInfixData+applyInfixDataWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the lhs field of hydra.scala.syntax.ApplyInfixData+applyInfixDataWithLhs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyInfixData+applyInfixDataWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the op field of hydra.scala.syntax.ApplyInfixData+applyInfixDataWithOp :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ApplyInfixData+applyInfixDataWithOp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the targs field of hydra.scala.syntax.ApplyInfixData+applyInfixDataWithTargs :: Typed.TypedTerm Syntax.ApplyInfixData -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ApplyInfixData+applyInfixDataWithTargs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ApplyInfixType+applyInfixType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplyInfixType+applyInfixType lhs op rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm op)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.ApplyInfixType+applyInfixTypeLhs :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type+applyInfixTypeLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the op field of hydra.scala.syntax.ApplyInfixType+applyInfixTypeOp :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.NameType+applyInfixTypeOp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.ApplyInfixType+applyInfixTypeRhs :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type+applyInfixTypeRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.ApplyInfixType+applyInfixTypeWithLhs :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplyInfixType+applyInfixTypeWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the op field of hydra.scala.syntax.ApplyInfixType+applyInfixTypeWithOp :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.ApplyInfixType+applyInfixTypeWithOp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.ApplyInfixType+applyInfixTypeWithRhs :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplyInfixType+applyInfixTypeWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyInfixType"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ApplyType+applyType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ApplyType+applyType tpe args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.ApplyType+applyTypeArgs :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm [Syntax.Type]+applyTypeArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.scala.syntax.ApplyTypeData+applyTypeData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyTypeData+applyTypeData lhs op targs args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm op)},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Typed.unTypedTerm targs)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.ApplyTypeData+applyTypeDataArgs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm [Syntax.Data]+applyTypeDataArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.ApplyTypeData+applyTypeDataLhs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.Data+applyTypeDataLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the op field of hydra.scala.syntax.ApplyTypeData+applyTypeDataOp :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.NameData+applyTypeDataOp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the targs field of hydra.scala.syntax.ApplyTypeData+applyTypeDataTargs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm [Syntax.Type]+applyTypeDataTargs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.ApplyTypeData+applyTypeDataWithArgs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyTypeData+applyTypeDataWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the lhs field of hydra.scala.syntax.ApplyTypeData+applyTypeDataWithLhs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyTypeData+applyTypeDataWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the op field of hydra.scala.syntax.ApplyTypeData+applyTypeDataWithOp :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ApplyTypeData+applyTypeDataWithOp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the targs field of hydra.scala.syntax.ApplyTypeData+applyTypeDataWithTargs :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ApplyTypeData+applyTypeDataWithTargs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyTypeData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.ApplyType+applyTypeTpe :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm Syntax.Type+applyTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.ApplyType+applyTypeWithArgs :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ApplyType+applyTypeWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.ApplyType+applyTypeWithTpe :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplyType+applyTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyType"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ApplyUnaryData+applyUnaryData :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyUnaryData+applyUnaryData op arg =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm op)},+ Core.Field {+ Core.fieldName = (Core.Name "arg"),+ Core.fieldTerm = (Typed.unTypedTerm arg)}]}))++-- | DSL accessor for the arg field of hydra.scala.syntax.ApplyUnaryData+applyUnaryDataArg :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.Data+applyUnaryDataArg x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),+ Core.projectionFieldName = (Core.Name "arg")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the op field of hydra.scala.syntax.ApplyUnaryData+applyUnaryDataOp :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.NameData+applyUnaryDataOp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the arg field of hydra.scala.syntax.ApplyUnaryData+applyUnaryDataWithArg :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyUnaryData+applyUnaryDataWithArg original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "arg"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the op field of hydra.scala.syntax.ApplyUnaryData+applyUnaryDataWithOp :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ApplyUnaryData+applyUnaryDataWithOp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "arg"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUnaryData"),+ Core.projectionFieldName = (Core.Name "arg")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ApplyUsingData+applyUsingData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyUsingData+applyUsingData fun targs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Typed.unTypedTerm fun)},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Typed.unTypedTerm targs)}]}))++-- | DSL accessor for the fun field of hydra.scala.syntax.ApplyUsingData+applyUsingDataFun :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm Syntax.Data+applyUsingDataFun x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),+ Core.projectionFieldName = (Core.Name "fun")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the targs field of hydra.scala.syntax.ApplyUsingData+applyUsingDataTargs :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm [Syntax.Data]+applyUsingDataTargs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the fun field of hydra.scala.syntax.ApplyUsingData+applyUsingDataWithFun :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ApplyUsingData+applyUsingDataWithFun original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),+ Core.projectionFieldName = (Core.Name "targs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the targs field of hydra.scala.syntax.ApplyUsingData+applyUsingDataWithTargs :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.ApplyUsingData+applyUsingDataWithTargs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ApplyUsingData"),+ Core.projectionFieldName = (Core.Name "fun")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "targs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.AscribeData+ascribeData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AscribeData+ascribeData expr tpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))++-- | DSL accessor for the expr field of hydra.scala.syntax.AscribeData+ascribeDataExpr :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Data+ascribeDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.AscribeData+ascribeDataTpe :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Type+ascribeDataTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expr field of hydra.scala.syntax.AscribeData+ascribeDataWithExpr :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AscribeData+ascribeDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.AscribeData+ascribeDataWithTpe :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AscribeData+ascribeDataWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AscribeData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.AssignData+assignData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AssignData+assignData lhs rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AssignData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.AssignData+assignDataLhs :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data+assignDataLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AssignData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.AssignData+assignDataRhs :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data+assignDataRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AssignData"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.AssignData+assignDataWithLhs :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AssignData+assignDataWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AssignData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AssignData"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.AssignData+assignDataWithRhs :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.AssignData+assignDataWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.AssignData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.AssignData"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.BindPat+bindPat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.BindPat+bindPat lhs rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.BindPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.BindPat+bindPatLhs :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat+bindPatLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.BindPat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.BindPat+bindPatRhs :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat+bindPatRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.BindPat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.BindPat+bindPatWithLhs :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.BindPat+bindPatWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.BindPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.BindPat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.BindPat+bindPatWithRhs :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.BindPat+bindPatWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.BindPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.BindPat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.BlockData+blockData :: Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.BlockData+blockData stats =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.BlockData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm stats)}]}))++-- | DSL accessor for the stats field of hydra.scala.syntax.BlockData+blockDataStats :: Typed.TypedTerm Syntax.BlockData -> Typed.TypedTerm [Syntax.Stat]+blockDataStats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.BlockData"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the stats field of hydra.scala.syntax.BlockData+blockDataWithStats :: Typed.TypedTerm Syntax.BlockData -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.BlockData+blockDataWithStats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.BlockData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ByNameType+byNameType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ByNameType+byNameType tpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ByNameType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.ByNameType+byNameTypeTpe :: Typed.TypedTerm Syntax.ByNameType -> Typed.TypedTerm Syntax.Type+byNameTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ByNameType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the tpe field of hydra.scala.syntax.ByNameType+byNameTypeWithTpe :: Typed.TypedTerm Syntax.ByNameType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ByNameType+byNameTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ByNameType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.Case+case_ :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Case+case_ pat cond body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm pat)},+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Typed.unTypedTerm cond)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.Case+caseBody :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.Data+caseBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the cond field of hydra.scala.syntax.Case+caseCond :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm (Maybe Syntax.Data)+caseCond x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "cond")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.scala.syntax.CaseGeneratorEnumerator+caseGeneratorEnumerator :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.CaseGeneratorEnumerator+caseGeneratorEnumerator pat rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm pat)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the pat field of hydra.scala.syntax.CaseGeneratorEnumerator+caseGeneratorEnumeratorPat :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Pat+caseGeneratorEnumeratorPat x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.CaseGeneratorEnumerator+caseGeneratorEnumeratorRhs :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Data+caseGeneratorEnumeratorRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the pat field of hydra.scala.syntax.CaseGeneratorEnumerator+caseGeneratorEnumeratorWithPat :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.CaseGeneratorEnumerator+caseGeneratorEnumeratorWithPat original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.CaseGeneratorEnumerator+caseGeneratorEnumeratorWithRhs :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.CaseGeneratorEnumerator+caseGeneratorEnumeratorWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the pat field of hydra.scala.syntax.Case+casePat :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.Pat+casePat x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL injection for the case variant of hydra.scala.syntax.CaseTree+caseTreeCase :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.CaseTree+caseTreeCase x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.CaseTree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "case"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the typeCase variant of hydra.scala.syntax.CaseTree+caseTreeTypeCase :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.CaseTree+caseTreeTypeCase x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.CaseTree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "typeCase"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL updater for the body field of hydra.scala.syntax.Case+caseWithBody :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Case+caseWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "cond")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the cond field of hydra.scala.syntax.Case+caseWithCond :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.Case+caseWithCond original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the pat field of hydra.scala.syntax.Case+caseWithPat :: Typed.TypedTerm Syntax.Case -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Case+caseWithPat original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "cond")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Case"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ClassDefn+classDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.ClassDefn+classDefn mods name tparams ctor template =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm ctor)},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm template)}]}))++-- | DSL accessor for the ctor field of hydra.scala.syntax.ClassDefn+classDefnCtor :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.PrimaryCtor+classDefnCtor x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.ClassDefn+classDefnMods :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm [Syntax.Mod]+classDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.ClassDefn+classDefnName :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.NameType+classDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the template field of hydra.scala.syntax.ClassDefn+classDefnTemplate :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.Template+classDefnTemplate x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.ClassDefn+classDefnTparams :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm [Syntax.ParamType]+classDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the ctor field of hydra.scala.syntax.ClassDefn+classDefnWithCtor :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.ClassDefn+classDefnWithCtor original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.ClassDefn+classDefnWithMods :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ClassDefn+classDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.ClassDefn+classDefnWithName :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.ClassDefn+classDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the template field of hydra.scala.syntax.ClassDefn+classDefnWithTemplate :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.ClassDefn+classDefnWithTemplate original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.ClassDefn+classDefnWithTparams :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.ClassDefn+classDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ClassDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ContextFunctionData+contextFunctionData :: Typed.TypedTerm [Syntax.ParamData] -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ContextFunctionData+contextFunctionData params body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm params)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.ContextFunctionData+contextFunctionDataBody :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm Syntax.Data+contextFunctionDataBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the params field of hydra.scala.syntax.ContextFunctionData+contextFunctionDataParams :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm [Syntax.ParamData]+contextFunctionDataParams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.ContextFunctionData+contextFunctionDataWithBody :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ContextFunctionData+contextFunctionDataWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the params field of hydra.scala.syntax.ContextFunctionData+contextFunctionDataWithParams :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm [Syntax.ParamData] -> Typed.TypedTerm Syntax.ContextFunctionData+contextFunctionDataWithParams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ContextFunctionType+contextFunctionType :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ContextFunctionType+contextFunctionType params res =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm params)},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Typed.unTypedTerm res)}]}))++-- | DSL accessor for the params field of hydra.scala.syntax.ContextFunctionType+contextFunctionTypeParams :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm [Syntax.Type]+contextFunctionTypeParams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the res field of hydra.scala.syntax.ContextFunctionType+contextFunctionTypeRes :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm Syntax.Type+contextFunctionTypeRes x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),+ Core.projectionFieldName = (Core.Name "res")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the params field of hydra.scala.syntax.ContextFunctionType+contextFunctionTypeWithParams :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ContextFunctionType+contextFunctionTypeWithParams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),+ Core.projectionFieldName = (Core.Name "res")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the res field of hydra.scala.syntax.ContextFunctionType+contextFunctionTypeWithRes :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ContextFunctionType+contextFunctionTypeWithRes original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ContextFunctionType"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the primary variant of hydra.scala.syntax.Ctor+ctorPrimary :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Ctor+ctorPrimary x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Ctor"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "primary"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the secondary variant of hydra.scala.syntax.Ctor+ctorSecondary :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Ctor+ctorSecondary x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Ctor"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "secondary"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the annotate variant of hydra.scala.syntax.Data+dataAnnotate :: Typed.TypedTerm Syntax.AnnotateData -> Typed.TypedTerm Syntax.Data+dataAnnotate x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "annotate"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the apply variant of hydra.scala.syntax.Data+dataApply :: Typed.TypedTerm Syntax.ApplyData -> Typed.TypedTerm Syntax.Data+dataApply x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "apply"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the applyType variant of hydra.scala.syntax.Data+dataApplyType :: Typed.TypedTerm Syntax.ApplyTypeData -> Typed.TypedTerm Syntax.Data+dataApplyType x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "applyType"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the applyUsing variant of hydra.scala.syntax.Data+dataApplyUsing :: Typed.TypedTerm Syntax.ApplyUsingData -> Typed.TypedTerm Syntax.Data+dataApplyUsing x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "applyUsing"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the ascribe variant of hydra.scala.syntax.Data+dataAscribe :: Typed.TypedTerm Syntax.AscribeData -> Typed.TypedTerm Syntax.Data+dataAscribe x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "ascribe"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the assign variant of hydra.scala.syntax.Data+dataAssign :: Typed.TypedTerm Syntax.AssignData -> Typed.TypedTerm Syntax.Data+dataAssign x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "assign"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the block variant of hydra.scala.syntax.Data+dataBlock :: Typed.TypedTerm Syntax.BlockData -> Typed.TypedTerm Syntax.Data+dataBlock x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "block"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the contextFunction variant of hydra.scala.syntax.Data+dataContextFunction :: Typed.TypedTerm Syntax.ContextFunctionData -> Typed.TypedTerm Syntax.Data+dataContextFunction x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "contextFunction"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the do variant of hydra.scala.syntax.Data+dataDo :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data+dataDo x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "do"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the endMarker variant of hydra.scala.syntax.Data+dataEndMarker :: Typed.TypedTerm Syntax.EndMarkerData -> Typed.TypedTerm Syntax.Data+dataEndMarker x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "endMarker"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the eta variant of hydra.scala.syntax.Data+dataEta :: Typed.TypedTerm Syntax.EtaData -> Typed.TypedTerm Syntax.Data+dataEta x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "eta"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the for variant of hydra.scala.syntax.Data+dataFor :: Typed.TypedTerm Syntax.ForData -> Typed.TypedTerm Syntax.Data+dataFor x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "for"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the forYield variant of hydra.scala.syntax.Data+dataForYield :: Typed.TypedTerm Syntax.ForYieldData -> Typed.TypedTerm Syntax.Data+dataForYield x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "forYield"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the function variant of hydra.scala.syntax.Data+dataFunction :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm Syntax.Data+dataFunction x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "function"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the if variant of hydra.scala.syntax.Data+dataIf :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data+dataIf x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "if"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the interpolate variant of hydra.scala.syntax.Data+dataInterpolate :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm Syntax.Data+dataInterpolate x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "interpolate"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the lit variant of hydra.scala.syntax.Data+dataLit :: Typed.TypedTerm Syntax.Lit -> Typed.TypedTerm Syntax.Data+dataLit x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "lit"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the match variant of hydra.scala.syntax.Data+dataMatch :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm Syntax.Data+dataMatch x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "match"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the object variant of hydra.scala.syntax.DataMember+dataMemberObject :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.DataMember+dataMemberObject x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.DataMember"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "object"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the pkg variant of hydra.scala.syntax.DataMember+dataMemberPkg :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.DataMember+dataMemberPkg x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.DataMember"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "pkg"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the new variant of hydra.scala.syntax.Data+dataNew :: Typed.TypedTerm Syntax.NewData -> Typed.TypedTerm Syntax.Data+dataNew x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "new"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the newAnonymous variant of hydra.scala.syntax.Data+dataNewAnonymous :: Typed.TypedTerm Syntax.NewAnonymousData -> Typed.TypedTerm Syntax.Data+dataNewAnonymous x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "newAnonymous"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the param variant of hydra.scala.syntax.Data+dataParam :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm Syntax.Data+dataParam x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "param"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the partialFunction variant of hydra.scala.syntax.Data+dataPartialFunction :: Typed.TypedTerm Syntax.PartialFunctionData -> Typed.TypedTerm Syntax.Data+dataPartialFunction x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "partialFunction"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the placeholder variant of hydra.scala.syntax.Data+dataPlaceholder :: Typed.TypedTerm Syntax.Data+dataPlaceholder =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "placeholder"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the polyFunction variant of hydra.scala.syntax.Data+dataPolyFunction :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm Syntax.Data+dataPolyFunction x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "polyFunction"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the ref variant of hydra.scala.syntax.Data+dataRef :: Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.Data+dataRef x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the repeated variant of hydra.scala.syntax.Data+dataRepeated :: Typed.TypedTerm Syntax.RepeatedData -> Typed.TypedTerm Syntax.Data+dataRepeated x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "repeated"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the return variant of hydra.scala.syntax.Data+dataReturn :: Typed.TypedTerm Syntax.ReturnData -> Typed.TypedTerm Syntax.Data+dataReturn x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "return"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the throw variant of hydra.scala.syntax.Data+dataThrow :: Typed.TypedTerm Syntax.ThrowData -> Typed.TypedTerm Syntax.Data+dataThrow x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "throw"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the try variant of hydra.scala.syntax.Data+dataTry :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm Syntax.Data+dataTry x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "try"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the tryWithHandler variant of hydra.scala.syntax.Data+dataTryWithHandler :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data+dataTryWithHandler x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "tryWithHandler"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the tuple variant of hydra.scala.syntax.Data+dataTuple :: Typed.TypedTerm Syntax.TupleData -> Typed.TypedTerm Syntax.Data+dataTuple x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "tuple"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the while variant of hydra.scala.syntax.Data+dataWhile :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data+dataWhile x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Data"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "while"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the def variant of hydra.scala.syntax.Decl+declDef :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.Decl+declDef x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "def"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the given variant of hydra.scala.syntax.Decl+declGiven :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.Decl+declGiven x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "given"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the type variant of hydra.scala.syntax.Decl+declType :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.Decl+declType x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "type"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the val variant of hydra.scala.syntax.Decl+declVal :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm Syntax.Decl+declVal x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "val"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the var variant of hydra.scala.syntax.Decl+declVar :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm Syntax.Decl+declVar x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Decl"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "var"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.DefDecl+defDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.DefDecl+defDecl mods name tparams paramss decltpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm paramss)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)}]}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.DefDecl+defDeclDecltpe :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.Type+defDeclDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.DefDecl+defDeclMods :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [Syntax.Mod]+defDeclMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.DefDecl+defDeclName :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.NameData+defDeclName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramss field of hydra.scala.syntax.DefDecl+defDeclParamss :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [[Syntax.ParamData]]+defDeclParamss x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.DefDecl+defDeclTparams :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [Syntax.ParamType]+defDeclTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.DefDecl+defDeclWithDecltpe :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.DefDecl+defDeclWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.DefDecl+defDeclWithMods :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.DefDecl+defDeclWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.DefDecl+defDeclWithName :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.DefDecl+defDeclWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramss field of hydra.scala.syntax.DefDecl+defDeclWithParamss :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.DefDecl+defDeclWithParamss original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.DefDecl+defDeclWithTparams :: Typed.TypedTerm Syntax.DefDecl -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.DefDecl+defDeclWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.DefDefn+defDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DefDefn+defDefn mods name tparams paramss decltpe body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm paramss)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.DefDefn+defDefnBody :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.Data+defDefnBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.DefDefn+defDefnDecltpe :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm (Maybe Syntax.Type)+defDefnDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.DefDefn+defDefnMods :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [Syntax.Mod]+defDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.DefDefn+defDefnName :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.NameData+defDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramss field of hydra.scala.syntax.DefDefn+defDefnParamss :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [[Syntax.ParamData]]+defDefnParamss x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.DefDefn+defDefnTparams :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [Syntax.ParamType]+defDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.DefDefn+defDefnWithBody :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DefDefn+defDefnWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.DefDefn+defDefnWithDecltpe :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.DefDefn+defDefnWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.DefDefn+defDefnWithMods :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.DefDefn+defDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.DefDefn+defDefnWithName :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.DefDefn+defDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramss field of hydra.scala.syntax.DefDefn+defDefnWithParamss :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.DefDefn+defDefnWithParamss original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.DefDefn+defDefnWithTparams :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.DefDefn+defDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DefDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the class variant of hydra.scala.syntax.Defn+defnClass :: Typed.TypedTerm Syntax.ClassDefn -> Typed.TypedTerm Syntax.Defn+defnClass x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "class"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the def variant of hydra.scala.syntax.Defn+defnDef :: Typed.TypedTerm Syntax.DefDefn -> Typed.TypedTerm Syntax.Defn+defnDef x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "def"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the enum variant of hydra.scala.syntax.Defn+defnEnum :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.Defn+defnEnum x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "enum"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the enumCase variant of hydra.scala.syntax.Defn+defnEnumCase :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.Defn+defnEnumCase x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "enumCase"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the extensionGroup variant of hydra.scala.syntax.Defn+defnExtensionGroup :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm Syntax.Defn+defnExtensionGroup x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "extensionGroup"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the given variant of hydra.scala.syntax.Defn+defnGiven :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Defn+defnGiven x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "given"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the givenAlias variant of hydra.scala.syntax.Defn+defnGivenAlias :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Defn+defnGivenAlias x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "givenAlias"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the object variant of hydra.scala.syntax.Defn+defnObject :: Typed.TypedTerm Syntax.ObjectDefn -> Typed.TypedTerm Syntax.Defn+defnObject x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "object"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the repeatedEnumCase variant of hydra.scala.syntax.Defn+defnRepeatedEnumCase :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm Syntax.Defn+defnRepeatedEnumCase x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "repeatedEnumCase"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the trait variant of hydra.scala.syntax.Defn+defnTrait :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.Defn+defnTrait x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "trait"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the type variant of hydra.scala.syntax.Defn+defnType :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.Defn+defnType x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "type"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the val variant of hydra.scala.syntax.Defn+defnVal :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm Syntax.Defn+defnVal x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "val"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the var variant of hydra.scala.syntax.Defn+defnVar :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm Syntax.Defn+defnVar x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Defn"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "var"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.DoData+doData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DoData+doData body expr =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DoData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)},+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.DoData+doDataBody :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data+doDataBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DoData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expr field of hydra.scala.syntax.DoData+doDataExpr :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data+doDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DoData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.DoData+doDataWithBody :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DoData+doDataWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DoData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DoData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the expr field of hydra.scala.syntax.DoData+doDataWithExpr :: Typed.TypedTerm Syntax.DoData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.DoData+doDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.DoData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.DoData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.EndMarkerData+endMarkerData :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.EndMarkerData+endMarkerData name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EndMarkerData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.EndMarkerData+endMarkerDataName :: Typed.TypedTerm Syntax.EndMarkerData -> Typed.TypedTerm Syntax.NameData+endMarkerDataName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EndMarkerData"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.EndMarkerData+endMarkerDataWithName :: Typed.TypedTerm Syntax.EndMarkerData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.EndMarkerData+endMarkerDataWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EndMarkerData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.EnumCaseDefn+enumCaseDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [Syntax.Init] -> Typed.TypedTerm Syntax.EnumCaseDefn+enumCaseDefn mods name tparams ctor inits =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm ctor)},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Typed.unTypedTerm inits)}]}))++-- | DSL accessor for the ctor field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnCtor :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.PrimaryCtor+enumCaseDefnCtor x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the inits field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnInits :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.Init]+enumCaseDefnInits x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnMods :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.Mod]+enumCaseDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnName :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.NameData+enumCaseDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnTparams :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.ParamType]+enumCaseDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the ctor field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnWithCtor :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.EnumCaseDefn+enumCaseDefnWithCtor original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the inits field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnWithInits :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.Init] -> Typed.TypedTerm Syntax.EnumCaseDefn+enumCaseDefnWithInits original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnWithMods :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.EnumCaseDefn+enumCaseDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnWithName :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.EnumCaseDefn+enumCaseDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.EnumCaseDefn+enumCaseDefnWithTparams :: Typed.TypedTerm Syntax.EnumCaseDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.EnumCaseDefn+enumCaseDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.EnumDefn+enumDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.EnumDefn+enumDefn mods name tparams ctor template =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm ctor)},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm template)}]}))++-- | DSL accessor for the ctor field of hydra.scala.syntax.EnumDefn+enumDefnCtor :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.PrimaryCtor+enumDefnCtor x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.EnumDefn+enumDefnMods :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm [Syntax.Mod]+enumDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.EnumDefn+enumDefnName :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.NameType+enumDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the template field of hydra.scala.syntax.EnumDefn+enumDefnTemplate :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.Template+enumDefnTemplate x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.EnumDefn+enumDefnTparams :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm [Syntax.ParamType]+enumDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the ctor field of hydra.scala.syntax.EnumDefn+enumDefnWithCtor :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.EnumDefn+enumDefnWithCtor original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.EnumDefn+enumDefnWithMods :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.EnumDefn+enumDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.EnumDefn+enumDefnWithName :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.EnumDefn+enumDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the template field of hydra.scala.syntax.EnumDefn+enumDefnWithTemplate :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.EnumDefn+enumDefnWithTemplate original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.EnumDefn+enumDefnWithTparams :: Typed.TypedTerm Syntax.EnumDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.EnumDefn+enumDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EnumDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the caseGenerator variant of hydra.scala.syntax.Enumerator+enumeratorCaseGenerator :: Typed.TypedTerm Syntax.CaseGeneratorEnumerator -> Typed.TypedTerm Syntax.Enumerator+enumeratorCaseGenerator x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Enumerator"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "caseGenerator"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the generator variant of hydra.scala.syntax.Enumerator+enumeratorGenerator :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Enumerator+enumeratorGenerator x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Enumerator"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "generator"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the guard variant of hydra.scala.syntax.Enumerator+enumeratorGuard :: Typed.TypedTerm Syntax.GuardEnumerator -> Typed.TypedTerm Syntax.Enumerator+enumeratorGuard x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Enumerator"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "guard"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the val variant of hydra.scala.syntax.Enumerator+enumeratorVal :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Enumerator+enumeratorVal x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Enumerator"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "val"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.EtaData+etaData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.EtaData+etaData expr =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EtaData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)}]}))++-- | DSL accessor for the expr field of hydra.scala.syntax.EtaData+etaDataExpr :: Typed.TypedTerm Syntax.EtaData -> Typed.TypedTerm Syntax.Data+etaDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.EtaData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expr field of hydra.scala.syntax.EtaData+etaDataWithExpr :: Typed.TypedTerm Syntax.EtaData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.EtaData+etaDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.EtaData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ExistentialType+existentialType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.ExistentialType+existentialType tpe stats =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm stats)}]}))++-- | DSL accessor for the stats field of hydra.scala.syntax.ExistentialType+existentialTypeStats :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm [Syntax.Stat]+existentialTypeStats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.ExistentialType+existentialTypeTpe :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm Syntax.Type+existentialTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the stats field of hydra.scala.syntax.ExistentialType+existentialTypeWithStats :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.ExistentialType+existentialTypeWithStats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.ExistentialType+existentialTypeWithTpe :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ExistentialType+existentialTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExistentialType"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.Export+export :: Typed.TypedTerm [Syntax.Importer] -> Typed.TypedTerm Syntax.Export+export importers =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Export"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "importers"),+ Core.fieldTerm = (Typed.unTypedTerm importers)}]}))++-- | DSL accessor for the importers field of hydra.scala.syntax.Export+exportImporters :: Typed.TypedTerm Syntax.Export -> Typed.TypedTerm [Syntax.Importer]+exportImporters x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Export"),+ Core.projectionFieldName = (Core.Name "importers")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the importers field of hydra.scala.syntax.Export+exportWithImporters :: Typed.TypedTerm Syntax.Export -> Typed.TypedTerm [Syntax.Importer] -> Typed.TypedTerm Syntax.Export+exportWithImporters original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Export"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "importers"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ExtensionGroupDefn+extensionGroupDefn :: Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Stat -> Typed.TypedTerm Syntax.ExtensionGroupDefn+extensionGroupDefn tparams parmss body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "parmss"),+ Core.fieldTerm = (Typed.unTypedTerm parmss)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.ExtensionGroupDefn+extensionGroupDefnBody :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm Syntax.Stat+extensionGroupDefnBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the parmss field of hydra.scala.syntax.ExtensionGroupDefn+extensionGroupDefnParmss :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm [[Syntax.ParamData]]+extensionGroupDefnParmss x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "parmss")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.ExtensionGroupDefn+extensionGroupDefnTparams :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm [Syntax.ParamType]+extensionGroupDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.ExtensionGroupDefn+extensionGroupDefnWithBody :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm Syntax.Stat -> Typed.TypedTerm Syntax.ExtensionGroupDefn+extensionGroupDefnWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "parmss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "parmss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the parmss field of hydra.scala.syntax.ExtensionGroupDefn+extensionGroupDefnWithParmss :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.ExtensionGroupDefn+extensionGroupDefnWithParmss original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "parmss"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.ExtensionGroupDefn+extensionGroupDefnWithTparams :: Typed.TypedTerm Syntax.ExtensionGroupDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.ExtensionGroupDefn+extensionGroupDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "parmss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "parmss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtensionGroupDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ExtractInfixPat+extractInfixPat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ExtractInfixPat+extractInfixPat lhs op rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm op)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.ExtractInfixPat+extractInfixPatLhs :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.Pat+extractInfixPatLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the op field of hydra.scala.syntax.ExtractInfixPat+extractInfixPatOp :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.NameData+extractInfixPatOp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.ExtractInfixPat+extractInfixPatRhs :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm [Syntax.Pat]+extractInfixPatRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.ExtractInfixPat+extractInfixPatWithLhs :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.ExtractInfixPat+extractInfixPatWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the op field of hydra.scala.syntax.ExtractInfixPat+extractInfixPatWithOp :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ExtractInfixPat+extractInfixPatWithOp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.ExtractInfixPat+extractInfixPatWithRhs :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ExtractInfixPat+extractInfixPatWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "op"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractInfixPat"),+ Core.projectionFieldName = (Core.Name "op")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ExtractPat+extractPat :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ExtractPat+extractPat fun args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Typed.unTypedTerm fun)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.ExtractPat+extractPatArgs :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm [Syntax.Pat]+extractPatArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the fun field of hydra.scala.syntax.ExtractPat+extractPatFun :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm Syntax.Data+extractPatFun x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),+ Core.projectionFieldName = (Core.Name "fun")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.ExtractPat+extractPatWithArgs :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ExtractPat+extractPatWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),+ Core.projectionFieldName = (Core.Name "fun")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the fun field of hydra.scala.syntax.ExtractPat+extractPatWithFun :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ExtractPat+extractPatWithFun original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "fun"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ExtractPat"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ForData+forData :: Typed.TypedTerm [Syntax.Enumerator] -> Typed.TypedTerm Syntax.ForData+forData enums =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ForData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "enums"),+ Core.fieldTerm = (Typed.unTypedTerm enums)}]}))++-- | DSL accessor for the enums field of hydra.scala.syntax.ForData+forDataEnums :: Typed.TypedTerm Syntax.ForData -> Typed.TypedTerm [Syntax.Enumerator]+forDataEnums x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ForData"),+ Core.projectionFieldName = (Core.Name "enums")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the enums field of hydra.scala.syntax.ForData+forDataWithEnums :: Typed.TypedTerm Syntax.ForData -> Typed.TypedTerm [Syntax.Enumerator] -> Typed.TypedTerm Syntax.ForData+forDataWithEnums original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ForData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "enums"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ForYieldData+forYieldData :: Typed.TypedTerm [Syntax.Enumerator] -> Typed.TypedTerm Syntax.ForYieldData+forYieldData enums =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ForYieldData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "enums"),+ Core.fieldTerm = (Typed.unTypedTerm enums)}]}))++-- | DSL accessor for the enums field of hydra.scala.syntax.ForYieldData+forYieldDataEnums :: Typed.TypedTerm Syntax.ForYieldData -> Typed.TypedTerm [Syntax.Enumerator]+forYieldDataEnums x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ForYieldData"),+ Core.projectionFieldName = (Core.Name "enums")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the enums field of hydra.scala.syntax.ForYieldData+forYieldDataWithEnums :: Typed.TypedTerm Syntax.ForYieldData -> Typed.TypedTerm [Syntax.Enumerator] -> Typed.TypedTerm Syntax.ForYieldData+forYieldDataWithEnums original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ForYieldData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "enums"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.FunctionData+functionData :: Typed.TypedTerm [Syntax.ParamData] -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.FunctionData+functionData params body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm params)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.FunctionData+functionDataBody :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm Syntax.Data+functionDataBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the params field of hydra.scala.syntax.FunctionData+functionDataParams :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm [Syntax.ParamData]+functionDataParams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.FunctionData+functionDataWithBody :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.FunctionData+functionDataWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the params field of hydra.scala.syntax.FunctionData+functionDataWithParams :: Typed.TypedTerm Syntax.FunctionData -> Typed.TypedTerm [Syntax.ParamData] -> Typed.TypedTerm Syntax.FunctionData+functionDataWithParams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.FunctionType+functionType :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType+functionType params res =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm params)},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Typed.unTypedTerm res)}]}))++-- | DSL accessor for the params field of hydra.scala.syntax.FunctionType+functionTypeParams :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm [Syntax.Type]+functionTypeParams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the res field of hydra.scala.syntax.FunctionType+functionTypeRes :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type+functionTypeRes x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),+ Core.projectionFieldName = (Core.Name "res")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the params field of hydra.scala.syntax.FunctionType+functionTypeWithParams :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.FunctionType+functionTypeWithParams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),+ Core.projectionFieldName = (Core.Name "res")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the res field of hydra.scala.syntax.FunctionType+functionTypeWithRes :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType+functionTypeWithRes original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.FunctionType"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.GeneratorEnumerator+generatorEnumerator :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GeneratorEnumerator+generatorEnumerator pat rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm pat)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the pat field of hydra.scala.syntax.GeneratorEnumerator+generatorEnumeratorPat :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Pat+generatorEnumeratorPat x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.GeneratorEnumerator+generatorEnumeratorRhs :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Data+generatorEnumeratorRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the pat field of hydra.scala.syntax.GeneratorEnumerator+generatorEnumeratorWithPat :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.GeneratorEnumerator+generatorEnumeratorWithPat original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.GeneratorEnumerator+generatorEnumeratorWithRhs :: Typed.TypedTerm Syntax.GeneratorEnumerator -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GeneratorEnumerator+generatorEnumeratorWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GeneratorEnumerator"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.GivenAliasDefn+givenAliasDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.ParamType]] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GivenAliasDefn+givenAliasDefn mods name tparams sparams decltpe body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Typed.unTypedTerm sparams)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnBody :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Data+givenAliasDefnBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnDecltpe :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Type+givenAliasDefnDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnMods :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [Syntax.Mod]+givenAliasDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnName :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Name+givenAliasDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the sparams field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnSparams :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [[Syntax.ParamData]]+givenAliasDefnSparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnTparams :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [[Syntax.ParamType]]+givenAliasDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnWithBody :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GivenAliasDefn+givenAliasDefnWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnWithDecltpe :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenAliasDefn+givenAliasDefnWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnWithMods :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.GivenAliasDefn+givenAliasDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnWithName :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.GivenAliasDefn+givenAliasDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the sparams field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnWithSparams :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.GivenAliasDefn+givenAliasDefnWithSparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.GivenAliasDefn+givenAliasDefnWithTparams :: Typed.TypedTerm Syntax.GivenAliasDefn -> Typed.TypedTerm [[Syntax.ParamType]] -> Typed.TypedTerm Syntax.GivenAliasDefn+givenAliasDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenAliasDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.GivenDecl+givenDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenDecl+givenDecl mods name tparams sparams decltpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Typed.unTypedTerm sparams)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)}]}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.GivenDecl+givenDeclDecltpe :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.Type+givenDeclDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.GivenDecl+givenDeclMods :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [Syntax.Mod]+givenDeclMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.GivenDecl+givenDeclName :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.NameData+givenDeclName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the sparams field of hydra.scala.syntax.GivenDecl+givenDeclSparams :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [[Syntax.ParamData]]+givenDeclSparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.GivenDecl+givenDeclTparams :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [Syntax.ParamType]+givenDeclTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.GivenDecl+givenDeclWithDecltpe :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenDecl+givenDeclWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.GivenDecl+givenDeclWithMods :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.GivenDecl+givenDeclWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.GivenDecl+givenDeclWithName :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.GivenDecl+givenDeclWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the sparams field of hydra.scala.syntax.GivenDecl+givenDeclWithSparams :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.GivenDecl+givenDeclWithSparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.GivenDecl+givenDeclWithTparams :: Typed.TypedTerm Syntax.GivenDecl -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.GivenDecl+givenDeclWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.GivenDefn+givenDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.ParamType]] -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.GivenDefn+givenDefn mods name tparams sparams templ =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Typed.unTypedTerm sparams)},+ Core.Field {+ Core.fieldName = (Core.Name "templ"),+ Core.fieldTerm = (Typed.unTypedTerm templ)}]}))++-- | DSL accessor for the mods field of hydra.scala.syntax.GivenDefn+givenDefnMods :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [Syntax.Mod]+givenDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.GivenDefn+givenDefnName :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Name+givenDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the sparams field of hydra.scala.syntax.GivenDefn+givenDefnSparams :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [[Syntax.ParamData]]+givenDefnSparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the templ field of hydra.scala.syntax.GivenDefn+givenDefnTempl :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Template+givenDefnTempl x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "templ")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.GivenDefn+givenDefnTparams :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [[Syntax.ParamType]]+givenDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the mods field of hydra.scala.syntax.GivenDefn+givenDefnWithMods :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.GivenDefn+givenDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "templ"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "templ")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.GivenDefn+givenDefnWithName :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.GivenDefn+givenDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "templ"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "templ")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the sparams field of hydra.scala.syntax.GivenDefn+givenDefnWithSparams :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.GivenDefn+givenDefnWithSparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "templ"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "templ")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the templ field of hydra.scala.syntax.GivenDefn+givenDefnWithTempl :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.GivenDefn+givenDefnWithTempl original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "templ"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.GivenDefn+givenDefnWithTparams :: Typed.TypedTerm Syntax.GivenDefn -> Typed.TypedTerm [[Syntax.ParamType]] -> Typed.TypedTerm Syntax.GivenDefn+givenDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "sparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "sparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "templ"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenDefn"),+ Core.projectionFieldName = (Core.Name "templ")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.GivenImportee+givenImportee :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenImportee+givenImportee tpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.GivenImportee+givenImporteeTpe :: Typed.TypedTerm Syntax.GivenImportee -> Typed.TypedTerm Syntax.Type+givenImporteeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenImportee"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the tpe field of hydra.scala.syntax.GivenImportee+givenImporteeWithTpe :: Typed.TypedTerm Syntax.GivenImportee -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenImportee+givenImporteeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.GivenPat+givenPat :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenPat+givenPat tpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.GivenPat+givenPatTpe :: Typed.TypedTerm Syntax.GivenPat -> Typed.TypedTerm Syntax.Type+givenPatTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GivenPat"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the tpe field of hydra.scala.syntax.GivenPat+givenPatWithTpe :: Typed.TypedTerm Syntax.GivenPat -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.GivenPat+givenPatWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GivenPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.GuardEnumerator+guardEnumerator :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GuardEnumerator+guardEnumerator cond =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GuardEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Typed.unTypedTerm cond)}]}))++-- | DSL accessor for the cond field of hydra.scala.syntax.GuardEnumerator+guardEnumeratorCond :: Typed.TypedTerm Syntax.GuardEnumerator -> Typed.TypedTerm Syntax.Data+guardEnumeratorCond x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.GuardEnumerator"),+ Core.projectionFieldName = (Core.Name "cond")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the cond field of hydra.scala.syntax.GuardEnumerator+guardEnumeratorWithCond :: Typed.TypedTerm Syntax.GuardEnumerator -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.GuardEnumerator+guardEnumeratorWithCond original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.GuardEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.IfData+ifData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.IfData+ifData cond thenp elsep =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Typed.unTypedTerm cond)},+ Core.Field {+ Core.fieldName = (Core.Name "thenp"),+ Core.fieldTerm = (Typed.unTypedTerm thenp)},+ Core.Field {+ Core.fieldName = (Core.Name "elsep"),+ Core.fieldTerm = (Typed.unTypedTerm elsep)}]}))++-- | DSL accessor for the cond field of hydra.scala.syntax.IfData+ifDataCond :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data+ifDataCond x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "cond")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the elsep field of hydra.scala.syntax.IfData+ifDataElsep :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data+ifDataElsep x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "elsep")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the thenp field of hydra.scala.syntax.IfData+ifDataThenp :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data+ifDataThenp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "thenp")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the cond field of hydra.scala.syntax.IfData+ifDataWithCond :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.IfData+ifDataWithCond original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "thenp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "thenp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "elsep"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "elsep")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the elsep field of hydra.scala.syntax.IfData+ifDataWithElsep :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.IfData+ifDataWithElsep original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "cond")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "thenp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "thenp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "elsep"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the thenp field of hydra.scala.syntax.IfData+ifDataWithThenp :: Typed.TypedTerm Syntax.IfData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.IfData+ifDataWithThenp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "cond"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "cond")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "thenp"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "elsep"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.IfData"),+ Core.projectionFieldName = (Core.Name "elsep")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ImplicitFunctionType+implicitFunctionType :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ImplicitFunctionType+implicitFunctionType params res =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm params)},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Typed.unTypedTerm res)}]}))++-- | DSL accessor for the params field of hydra.scala.syntax.ImplicitFunctionType+implicitFunctionTypeParams :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm [Syntax.Type]+implicitFunctionTypeParams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the res field of hydra.scala.syntax.ImplicitFunctionType+implicitFunctionTypeRes :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm Syntax.Type+implicitFunctionTypeRes x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),+ Core.projectionFieldName = (Core.Name "res")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the params field of hydra.scala.syntax.ImplicitFunctionType+implicitFunctionTypeWithParams :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ImplicitFunctionType+implicitFunctionTypeWithParams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),+ Core.projectionFieldName = (Core.Name "res")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the res field of hydra.scala.syntax.ImplicitFunctionType+implicitFunctionTypeWithRes :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ImplicitFunctionType+implicitFunctionTypeWithRes original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "params"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ImplicitFunctionType"),+ Core.projectionFieldName = (Core.Name "params")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "res"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.Import+import_ :: Typed.TypedTerm [Syntax.Importer] -> Typed.TypedTerm Syntax.Import+import_ importers =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Import"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "importers"),+ Core.fieldTerm = (Typed.unTypedTerm importers)}]}))++-- | DSL injection for the export variant of hydra.scala.syntax.ImportExportStat+importExportStatExport :: Typed.TypedTerm Syntax.Export -> Typed.TypedTerm Syntax.ImportExportStat+importExportStatExport x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.ImportExportStat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "export"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the import variant of hydra.scala.syntax.ImportExportStat+importExportStatImport :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm Syntax.ImportExportStat+importExportStatImport x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.ImportExportStat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "import"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL accessor for the importers field of hydra.scala.syntax.Import+importImporters :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm [Syntax.Importer]+importImporters x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Import"),+ Core.projectionFieldName = (Core.Name "importers")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the importers field of hydra.scala.syntax.Import+importWithImporters :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm [Syntax.Importer] -> Typed.TypedTerm Syntax.Import+importWithImporters original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Import"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "importers"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the given variant of hydra.scala.syntax.Importee+importeeGiven :: Typed.TypedTerm Syntax.GivenImportee -> Typed.TypedTerm Syntax.Importee+importeeGiven x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "given"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the givenAll variant of hydra.scala.syntax.Importee+importeeGivenAll :: Typed.TypedTerm Syntax.Importee+importeeGivenAll =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "givenAll"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the name variant of hydra.scala.syntax.Importee+importeeName :: Typed.TypedTerm Syntax.NameImportee -> Typed.TypedTerm Syntax.Importee+importeeName x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the rename variant of hydra.scala.syntax.Importee+importeeRename :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Importee+importeeRename x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "rename"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the unimport variant of hydra.scala.syntax.Importee+importeeUnimport :: Typed.TypedTerm Syntax.UnimportImportee -> Typed.TypedTerm Syntax.Importee+importeeUnimport x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "unimport"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the wildcard variant of hydra.scala.syntax.Importee+importeeWildcard :: Typed.TypedTerm Syntax.Importee+importeeWildcard =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Importee"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "wildcard"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.scala.syntax.Importer+importer :: Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm [Syntax.Importee] -> Typed.TypedTerm Syntax.Importer+importer ref importees =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Importer"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm ref)},+ Core.Field {+ Core.fieldName = (Core.Name "importees"),+ Core.fieldTerm = (Typed.unTypedTerm importees)}]}))++-- | DSL accessor for the importees field of hydra.scala.syntax.Importer+importerImportees :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm [Syntax.Importee]+importerImportees x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Importer"),+ Core.projectionFieldName = (Core.Name "importees")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the ref field of hydra.scala.syntax.Importer+importerRef :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm Syntax.RefData+importerRef x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Importer"),+ Core.projectionFieldName = (Core.Name "ref")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the importees field of hydra.scala.syntax.Importer+importerWithImportees :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm [Syntax.Importee] -> Typed.TypedTerm Syntax.Importer+importerWithImportees original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Importer"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Importer"),+ Core.projectionFieldName = (Core.Name "ref")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "importees"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the ref field of hydra.scala.syntax.Importer+importerWithRef :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.Importer+importerWithRef original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Importer"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "importees"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Importer"),+ Core.projectionFieldName = (Core.Name "importees")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.Init+init :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.Data]] -> Typed.TypedTerm Syntax.Init+init tpe name argss =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "argss"),+ Core.fieldTerm = (Typed.unTypedTerm argss)}]}))++-- | DSL accessor for the argss field of hydra.scala.syntax.Init+initArgss :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm [[Syntax.Data]]+initArgss x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "argss")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.Init+initName :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Name+initName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.Init+initTpe :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Type+initTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the argss field of hydra.scala.syntax.Init+initWithArgss :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm [[Syntax.Data]] -> Typed.TypedTerm Syntax.Init+initWithArgss original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "argss"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.scala.syntax.Init+initWithName :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Init+initWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "argss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "argss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.Init+initWithTpe :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Init+initWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "argss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Init"),+ Core.projectionFieldName = (Core.Name "argss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.InterpolateData+interpolateData :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Lit] -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.InterpolateData+interpolateData prefix parts args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "prefix"),+ Core.fieldTerm = (Typed.unTypedTerm prefix)},+ Core.Field {+ Core.fieldName = (Core.Name "parts"),+ Core.fieldTerm = (Typed.unTypedTerm parts)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.InterpolateData+interpolateDataArgs :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm [Syntax.Data]+interpolateDataArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the parts field of hydra.scala.syntax.InterpolateData+interpolateDataParts :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm [Syntax.Lit]+interpolateDataParts x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "parts")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the prefix field of hydra.scala.syntax.InterpolateData+interpolateDataPrefix :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm Syntax.NameData+interpolateDataPrefix x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "prefix")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.InterpolateData+interpolateDataWithArgs :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.InterpolateData+interpolateDataWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "prefix"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "prefix")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "parts"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "parts")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the parts field of hydra.scala.syntax.InterpolateData+interpolateDataWithParts :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm [Syntax.Lit] -> Typed.TypedTerm Syntax.InterpolateData+interpolateDataWithParts original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "prefix"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "prefix")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "parts"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the prefix field of hydra.scala.syntax.InterpolateData+interpolateDataWithPrefix :: Typed.TypedTerm Syntax.InterpolateData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.InterpolateData+interpolateDataWithPrefix original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "prefix"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "parts"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "parts")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolateData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.InterpolatePat+interpolatePat :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm [Syntax.Lit] -> Typed.TypedTerm Syntax.InterpolatePat+interpolatePat prefix parts =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "prefix"),+ Core.fieldTerm = (Typed.unTypedTerm prefix)},+ Core.Field {+ Core.fieldName = (Core.Name "parts"),+ Core.fieldTerm = (Typed.unTypedTerm parts)}]}))++-- | DSL accessor for the parts field of hydra.scala.syntax.InterpolatePat+interpolatePatParts :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm [Syntax.Lit]+interpolatePatParts x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),+ Core.projectionFieldName = (Core.Name "parts")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the prefix field of hydra.scala.syntax.InterpolatePat+interpolatePatPrefix :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm Syntax.NameData+interpolatePatPrefix x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),+ Core.projectionFieldName = (Core.Name "prefix")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the parts field of hydra.scala.syntax.InterpolatePat+interpolatePatWithParts :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm [Syntax.Lit] -> Typed.TypedTerm Syntax.InterpolatePat+interpolatePatWithParts original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "prefix"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),+ Core.projectionFieldName = (Core.Name "prefix")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "parts"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the prefix field of hydra.scala.syntax.InterpolatePat+interpolatePatWithPrefix :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.InterpolatePat+interpolatePatWithPrefix original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "prefix"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "parts"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.InterpolatePat"),+ Core.projectionFieldName = (Core.Name "parts")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.LambdaType+lambdaType :: Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LambdaType+lambdaType tparams tpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.LambdaType+lambdaTypeTparams :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm [Syntax.ParamType]+lambdaTypeTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.LambdaType+lambdaTypeTpe :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm Syntax.Type+lambdaTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the tparams field of hydra.scala.syntax.LambdaType+lambdaTypeWithTparams :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.LambdaType+lambdaTypeWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.LambdaType+lambdaTypeWithTpe :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LambdaType+lambdaTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.LambdaType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the boolean variant of hydra.scala.syntax.Lit+litBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Lit+litBoolean x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "boolean"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the byte variant of hydra.scala.syntax.Lit+litByte :: Typed.TypedTerm I.Int8 -> Typed.TypedTerm Syntax.Lit+litByte x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "byte"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the bytes variant of hydra.scala.syntax.Lit+litBytes :: Typed.TypedTerm [Int] -> Typed.TypedTerm Syntax.Lit+litBytes x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "bytes"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the char variant of hydra.scala.syntax.Lit+litChar :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.Lit+litChar x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "char"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the double variant of hydra.scala.syntax.Lit+litDouble :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.Lit+litDouble x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "double"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the float variant of hydra.scala.syntax.Lit+litFloat :: Typed.TypedTerm Float -> Typed.TypedTerm Syntax.Lit+litFloat x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "float"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the int variant of hydra.scala.syntax.Lit+litInt :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.Lit+litInt x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "int"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the long variant of hydra.scala.syntax.Lit+litLong :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Syntax.Lit+litLong x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "long"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the null variant of hydra.scala.syntax.Lit+litNull :: Typed.TypedTerm Syntax.Lit+litNull =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "null"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the short variant of hydra.scala.syntax.Lit+litShort :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Syntax.Lit+litShort x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "short"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the string variant of hydra.scala.syntax.Lit+litString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Lit+litString x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "string"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the symbol variant of hydra.scala.syntax.Lit+litSymbol :: Typed.TypedTerm Syntax.ScalaSymbol -> Typed.TypedTerm Syntax.Lit+litSymbol x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "symbol"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the unit variant of hydra.scala.syntax.Lit+litUnit :: Typed.TypedTerm Syntax.Lit+litUnit =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Lit"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "unit"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.scala.syntax.MatchData+matchData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.MatchData+matchData expr cases =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Typed.unTypedTerm cases)}]}))++-- | DSL accessor for the cases field of hydra.scala.syntax.MatchData+matchDataCases :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm [Syntax.Case]+matchDataCases x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchData"),+ Core.projectionFieldName = (Core.Name "cases")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expr field of hydra.scala.syntax.MatchData+matchDataExpr :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm Syntax.Data+matchDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the cases field of hydra.scala.syntax.MatchData+matchDataWithCases :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.MatchData+matchDataWithCases original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the expr field of hydra.scala.syntax.MatchData+matchDataWithExpr :: Typed.TypedTerm Syntax.MatchData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.MatchData+matchDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchData"),+ Core.projectionFieldName = (Core.Name "cases")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.MatchType+matchType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.TypeCase] -> Typed.TypedTerm Syntax.MatchType+matchType tpe cases =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Typed.unTypedTerm cases)}]}))++-- | DSL accessor for the cases field of hydra.scala.syntax.MatchType+matchTypeCases :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm [Syntax.TypeCase]+matchTypeCases x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchType"),+ Core.projectionFieldName = (Core.Name "cases")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.MatchType+matchTypeTpe :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm Syntax.Type+matchTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the cases field of hydra.scala.syntax.MatchType+matchTypeWithCases :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm [Syntax.TypeCase] -> Typed.TypedTerm Syntax.MatchType+matchTypeWithCases original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.MatchType+matchTypeWithTpe :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MatchType+matchTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MatchType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MatchType"),+ Core.projectionFieldName = (Core.Name "cases")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the self variant of hydra.scala.syntax.Member+memberSelf :: Typed.TypedTerm Syntax.Self -> Typed.TypedTerm Syntax.Member+memberSelf x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "self"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the term variant of hydra.scala.syntax.Member+memberTerm :: Typed.TypedTerm Syntax.DataMember -> Typed.TypedTerm Syntax.Member+memberTerm x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "term"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the termParam variant of hydra.scala.syntax.Member+memberTermParam :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm Syntax.Member+memberTermParam x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "termParam"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the type variant of hydra.scala.syntax.Member+memberType :: Typed.TypedTerm Syntax.TypeMember -> Typed.TypedTerm Syntax.Member+memberType x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "type"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the typeParam variant of hydra.scala.syntax.Member+memberTypeParam :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm Syntax.Member+memberTypeParam x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Member"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "typeParam"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.MethodType+methodType :: Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MethodType+methodType paramss tpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MethodType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm paramss)},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))++-- | DSL accessor for the paramss field of hydra.scala.syntax.MethodType+methodTypeParamss :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm [[Syntax.ParamData]]+methodTypeParamss x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MethodType"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.MethodType+methodTypeTpe :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm Syntax.Type+methodTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MethodType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the paramss field of hydra.scala.syntax.MethodType+methodTypeWithParamss :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.MethodType+methodTypeWithParamss original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MethodType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MethodType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.MethodType+methodTypeWithTpe :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MethodType+methodTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.MethodType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.MethodType"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the abstract variant of hydra.scala.syntax.Mod+modAbstract :: Typed.TypedTerm Syntax.Mod+modAbstract =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "abstract"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the annot variant of hydra.scala.syntax.Mod+modAnnot :: Typed.TypedTerm Syntax.AnnotMod -> Typed.TypedTerm Syntax.Mod+modAnnot x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "annot"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the case variant of hydra.scala.syntax.Mod+modCase :: Typed.TypedTerm Syntax.Mod+modCase =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "case"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the contravariant variant of hydra.scala.syntax.Mod+modContravariant :: Typed.TypedTerm Syntax.Mod+modContravariant =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "contravariant"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the covariant variant of hydra.scala.syntax.Mod+modCovariant :: Typed.TypedTerm Syntax.Mod+modCovariant =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "covariant"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the final variant of hydra.scala.syntax.Mod+modFinal :: Typed.TypedTerm Syntax.Mod+modFinal =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "final"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the implicit variant of hydra.scala.syntax.Mod+modImplicit :: Typed.TypedTerm Syntax.Mod+modImplicit =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "implicit"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the infix variant of hydra.scala.syntax.Mod+modInfix :: Typed.TypedTerm Syntax.Mod+modInfix =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "infix"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the inline variant of hydra.scala.syntax.Mod+modInline :: Typed.TypedTerm Syntax.Mod+modInline =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "inline"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the lazy variant of hydra.scala.syntax.Mod+modLazy :: Typed.TypedTerm Syntax.Mod+modLazy =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "lazy"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the opaque variant of hydra.scala.syntax.Mod+modOpaque :: Typed.TypedTerm Syntax.Mod+modOpaque =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "opaque"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the open variant of hydra.scala.syntax.Mod+modOpen :: Typed.TypedTerm Syntax.Mod+modOpen =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "open"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the override variant of hydra.scala.syntax.Mod+modOverride :: Typed.TypedTerm Syntax.Mod+modOverride =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "override"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the private variant of hydra.scala.syntax.Mod+modPrivate :: Typed.TypedTerm Syntax.PrivateMod -> Typed.TypedTerm Syntax.Mod+modPrivate x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "private"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the protected variant of hydra.scala.syntax.Mod+modProtected :: Typed.TypedTerm Syntax.ProtectedMod -> Typed.TypedTerm Syntax.Mod+modProtected x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "protected"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the sealed variant of hydra.scala.syntax.Mod+modSealed :: Typed.TypedTerm Syntax.Mod+modSealed =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "sealed"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the super variant of hydra.scala.syntax.Mod+modSuper :: Typed.TypedTerm Syntax.Mod+modSuper =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "super"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the transparent variant of hydra.scala.syntax.Mod+modTransparent :: Typed.TypedTerm Syntax.Mod+modTransparent =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "transparent"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the using variant of hydra.scala.syntax.Mod+modUsing :: Typed.TypedTerm Syntax.Mod+modUsing =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "using"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the valParam variant of hydra.scala.syntax.Mod+modValParam :: Typed.TypedTerm Syntax.Mod+modValParam =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "valParam"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the varParam variant of hydra.scala.syntax.Mod+modVarParam :: Typed.TypedTerm Syntax.Mod+modVarParam =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Mod"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "varParam"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the anonymous variant of hydra.scala.syntax.Name+nameAnonymous :: Typed.TypedTerm Syntax.Name+nameAnonymous =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Name"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "anonymous"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.scala.syntax.NameData+nameData :: Typed.TypedTerm Syntax.PredefString -> Typed.TypedTerm Syntax.NameData+nameData value =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "value"),+ Core.fieldTerm = (Typed.unTypedTerm value)}]}))++-- | DSL accessor for the value field of hydra.scala.syntax.NameData+nameDataValue :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.PredefString+nameDataValue x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NameData"),+ Core.projectionFieldName = (Core.Name "value")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the value field of hydra.scala.syntax.NameData+nameDataWithValue :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.PredefString -> Typed.TypedTerm Syntax.NameData+nameDataWithValue original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "value"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.NameImportee+nameImportee :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.NameImportee+nameImportee name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.NameImportee+nameImporteeName :: Typed.TypedTerm Syntax.NameImportee -> Typed.TypedTerm Syntax.Name+nameImporteeName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NameImportee"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.NameImportee+nameImporteeWithName :: Typed.TypedTerm Syntax.NameImportee -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.NameImportee+nameImporteeWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the indeterminate variant of hydra.scala.syntax.Name+nameIndeterminate :: Typed.TypedTerm Syntax.PredefString -> Typed.TypedTerm Syntax.Name+nameIndeterminate x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Name"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "indeterminate"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.NameType+nameType :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.NameType+nameType value =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "value"),+ Core.fieldTerm = (Typed.unTypedTerm value)}]}))++-- | DSL accessor for the value field of hydra.scala.syntax.NameType+nameTypeValue :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm String+nameTypeValue x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NameType"),+ Core.projectionFieldName = (Core.Name "value")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the value field of hydra.scala.syntax.NameType+nameTypeWithValue :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.NameType+nameTypeWithValue original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NameType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "value"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the value variant of hydra.scala.syntax.Name+nameValue :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Name+nameValue x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Name"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "value"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.NewAnonymousData+newAnonymousData :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.NewAnonymousData+newAnonymousData templ =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NewAnonymousData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "templ"),+ Core.fieldTerm = (Typed.unTypedTerm templ)}]}))++-- | DSL accessor for the templ field of hydra.scala.syntax.NewAnonymousData+newAnonymousDataTempl :: Typed.TypedTerm Syntax.NewAnonymousData -> Typed.TypedTerm Syntax.Template+newAnonymousDataTempl x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NewAnonymousData"),+ Core.projectionFieldName = (Core.Name "templ")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the templ field of hydra.scala.syntax.NewAnonymousData+newAnonymousDataWithTempl :: Typed.TypedTerm Syntax.NewAnonymousData -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.NewAnonymousData+newAnonymousDataWithTempl original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NewAnonymousData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "templ"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.NewData+newData :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.NewData+newData init =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NewData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Typed.unTypedTerm init)}]}))++-- | DSL accessor for the init field of hydra.scala.syntax.NewData+newDataInit :: Typed.TypedTerm Syntax.NewData -> Typed.TypedTerm Syntax.Init+newDataInit x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.NewData"),+ Core.projectionFieldName = (Core.Name "init")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the init field of hydra.scala.syntax.NewData+newDataWithInit :: Typed.TypedTerm Syntax.NewData -> Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.NewData+newDataWithInit original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.NewData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ObjectDefn+objectDefn :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ObjectDefn+objectDefn name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.ObjectDefn+objectDefnName :: Typed.TypedTerm Syntax.ObjectDefn -> Typed.TypedTerm Syntax.NameData+objectDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.ObjectDefn+objectDefnWithName :: Typed.TypedTerm Syntax.ObjectDefn -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ObjectDefn+objectDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ObjectPkg+objectPkg :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.ObjectPkg+objectPkg mods name template =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm template)}]}))++-- | DSL accessor for the mods field of hydra.scala.syntax.ObjectPkg+objectPkgMods :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm [Syntax.Mod]+objectPkgMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.ObjectPkg+objectPkgName :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.NameData+objectPkgName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the template field of hydra.scala.syntax.ObjectPkg+objectPkgTemplate :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.Template+objectPkgTemplate x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the mods field of hydra.scala.syntax.ObjectPkg+objectPkgWithMods :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ObjectPkg+objectPkgWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.ObjectPkg+objectPkgWithName :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.ObjectPkg+objectPkgWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the template field of hydra.scala.syntax.ObjectPkg+objectPkgWithTemplate :: Typed.TypedTerm Syntax.ObjectPkg -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.ObjectPkg+objectPkgWithTemplate original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ObjectPkg"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.OrType+orType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OrType+orType lhs rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.OrType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.OrType+orTypeLhs :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type+orTypeLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.OrType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.OrType+orTypeRhs :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type+orTypeRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.OrType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.OrType+orTypeWithLhs :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OrType+orTypeWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.OrType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.OrType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.OrType+orTypeWithRhs :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OrType+orTypeWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.OrType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.OrType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ParamData+paramData :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.ParamData+paramData mods name decltpe default_ =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)},+ Core.Field {+ Core.fieldName = (Core.Name "default"),+ Core.fieldTerm = (Typed.unTypedTerm default_)}]}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.ParamData+paramDataDecltpe :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm (Maybe Syntax.Type)+paramDataDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the default field of hydra.scala.syntax.ParamData+paramDataDefault :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm (Maybe Syntax.Data)+paramDataDefault x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "default")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.ParamData+paramDataMods :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm [Syntax.Mod]+paramDataMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.ParamData+paramDataName :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm Syntax.Name+paramDataName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.ParamData+paramDataWithDecltpe :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.ParamData+paramDataWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "default"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "default")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the default field of hydra.scala.syntax.ParamData+paramDataWithDefault :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.ParamData+paramDataWithDefault original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "default"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.ParamData+paramDataWithMods :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ParamData+paramDataWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "default"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "default")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.ParamData+paramDataWithName :: Typed.TypedTerm Syntax.ParamData -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ParamData+paramDataWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "default"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamData"),+ Core.projectionFieldName = (Core.Name "default")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ParamType+paramType :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm [Syntax.TypeBounds] -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ParamType+paramType mods name tparams tbounds vbounds cbounds =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "tbounds"),+ Core.fieldTerm = (Typed.unTypedTerm tbounds)},+ Core.Field {+ Core.fieldName = (Core.Name "vbounds"),+ Core.fieldTerm = (Typed.unTypedTerm vbounds)},+ Core.Field {+ Core.fieldName = (Core.Name "cbounds"),+ Core.fieldTerm = (Typed.unTypedTerm cbounds)}]}))++-- | DSL accessor for the cbounds field of hydra.scala.syntax.ParamType+paramTypeCbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Type]+paramTypeCbounds x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "cbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.ParamType+paramTypeMods :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Mod]+paramTypeMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.ParamType+paramTypeName :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm Syntax.Name+paramTypeName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tbounds field of hydra.scala.syntax.ParamType+paramTypeTbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.TypeBounds]+paramTypeTbounds x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.ParamType+paramTypeTparams :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.ParamType]+paramTypeTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the vbounds field of hydra.scala.syntax.ParamType+paramTypeVbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Type]+paramTypeVbounds x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "vbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the cbounds field of hydra.scala.syntax.ParamType+paramTypeWithCbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ParamType+paramTypeWithCbounds original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "vbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "vbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cbounds"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.ParamType+paramTypeWithMods :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ParamType+paramTypeWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "vbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "vbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "cbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.ParamType+paramTypeWithName :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ParamType+paramTypeWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "vbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "vbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "cbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tbounds field of hydra.scala.syntax.ParamType+paramTypeWithTbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.TypeBounds] -> Typed.TypedTerm Syntax.ParamType+paramTypeWithTbounds original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tbounds"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "vbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "vbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "cbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.ParamType+paramTypeWithTparams :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.ParamType+paramTypeWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "vbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "vbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "cbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the vbounds field of hydra.scala.syntax.ParamType+paramTypeWithVbounds :: Typed.TypedTerm Syntax.ParamType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ParamType+paramTypeWithVbounds original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "tbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "vbounds"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "cbounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ParamType"),+ Core.projectionFieldName = (Core.Name "cbounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.PartialFunctionData+partialFunctionData :: Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.PartialFunctionData+partialFunctionData cases =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PartialFunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Typed.unTypedTerm cases)}]}))++-- | DSL accessor for the cases field of hydra.scala.syntax.PartialFunctionData+partialFunctionDataCases :: Typed.TypedTerm Syntax.PartialFunctionData -> Typed.TypedTerm [Syntax.Case]+partialFunctionDataCases x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PartialFunctionData"),+ Core.projectionFieldName = (Core.Name "cases")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the cases field of hydra.scala.syntax.PartialFunctionData+partialFunctionDataWithCases :: Typed.TypedTerm Syntax.PartialFunctionData -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.PartialFunctionData+partialFunctionDataWithCases original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PartialFunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the alternative variant of hydra.scala.syntax.Pat+patAlternative :: Typed.TypedTerm Syntax.AlternativePat -> Typed.TypedTerm Syntax.Pat+patAlternative x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "alternative"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the bind variant of hydra.scala.syntax.Pat+patBind :: Typed.TypedTerm Syntax.BindPat -> Typed.TypedTerm Syntax.Pat+patBind x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "bind"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the extract variant of hydra.scala.syntax.Pat+patExtract :: Typed.TypedTerm Syntax.ExtractPat -> Typed.TypedTerm Syntax.Pat+patExtract x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "extract"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the extractInfix variant of hydra.scala.syntax.Pat+patExtractInfix :: Typed.TypedTerm Syntax.ExtractInfixPat -> Typed.TypedTerm Syntax.Pat+patExtractInfix x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "extractInfix"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the given variant of hydra.scala.syntax.Pat+patGiven :: Typed.TypedTerm Syntax.GivenPat -> Typed.TypedTerm Syntax.Pat+patGiven x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "given"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the interpolate variant of hydra.scala.syntax.Pat+patInterpolate :: Typed.TypedTerm Syntax.InterpolatePat -> Typed.TypedTerm Syntax.Pat+patInterpolate x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "interpolate"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the repeated variant of hydra.scala.syntax.Pat+patRepeated :: Typed.TypedTerm Syntax.RepeatedPat -> Typed.TypedTerm Syntax.Pat+patRepeated x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "repeated"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the seqWildcard variant of hydra.scala.syntax.Pat+patSeqWildcard :: Typed.TypedTerm Syntax.Pat+patSeqWildcard =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "seqWildcard"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the tuple variant of hydra.scala.syntax.Pat+patTuple :: Typed.TypedTerm Syntax.TuplePat -> Typed.TypedTerm Syntax.Pat+patTuple x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "tuple"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the typed variant of hydra.scala.syntax.Pat+patTyped :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Pat+patTyped x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "typed"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the var variant of hydra.scala.syntax.Pat+patVar :: Typed.TypedTerm Syntax.VarPat -> Typed.TypedTerm Syntax.Pat+patVar x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "var"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the wildcard variant of hydra.scala.syntax.Pat+patWildcard :: Typed.TypedTerm Syntax.Pat+patWildcard =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Pat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "wildcard"),+ Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.scala.syntax.Pkg+pkg :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Pkg+pkg name ref stats =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm ref)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm stats)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.Pkg+pkgName :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.NameData+pkgName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the ref field of hydra.scala.syntax.Pkg+pkgRef :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.RefData+pkgRef x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "ref")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the stats field of hydra.scala.syntax.Pkg+pkgStats :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm [Syntax.Stat]+pkgStats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.Pkg+pkgWithName :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.Pkg+pkgWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "ref")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the ref field of hydra.scala.syntax.Pkg+pkgWithRef :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.Pkg+pkgWithRef original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the stats field of hydra.scala.syntax.Pkg+pkgWithStats :: Typed.TypedTerm Syntax.Pkg -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Pkg+pkgWithStats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Pkg"),+ Core.projectionFieldName = (Core.Name "ref")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.PlaceholderType+placeholderType :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.PlaceholderType+placeholderType bounds =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PlaceholderType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "bounds"),+ Core.fieldTerm = (Typed.unTypedTerm bounds)}]}))++-- | DSL accessor for the bounds field of hydra.scala.syntax.PlaceholderType+placeholderTypeBounds :: Typed.TypedTerm Syntax.PlaceholderType -> Typed.TypedTerm Syntax.TypeBounds+placeholderTypeBounds x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PlaceholderType"),+ Core.projectionFieldName = (Core.Name "bounds")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the bounds field of hydra.scala.syntax.PlaceholderType+placeholderTypeWithBounds :: Typed.TypedTerm Syntax.PlaceholderType -> Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.PlaceholderType+placeholderTypeWithBounds original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PlaceholderType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "bounds"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.PolyFunctionData+polyFunctionData :: Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.PolyFunctionData+polyFunctionData tparams body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.PolyFunctionData+polyFunctionDataBody :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm Syntax.Data+polyFunctionDataBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.PolyFunctionData+polyFunctionDataTparams :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm [Syntax.ParamType]+polyFunctionDataTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.PolyFunctionData+polyFunctionDataWithBody :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.PolyFunctionData+polyFunctionDataWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.PolyFunctionData+polyFunctionDataWithTparams :: Typed.TypedTerm Syntax.PolyFunctionData -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PolyFunctionData+polyFunctionDataWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.PolyFunctionType+polyFunctionType :: Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.PolyFunctionType+polyFunctionType tparams tpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.PolyFunctionType+polyFunctionTypeTparams :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm [Syntax.ParamType]+polyFunctionTypeTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.PolyFunctionType+polyFunctionTypeTpe :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm Syntax.Type+polyFunctionTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the tparams field of hydra.scala.syntax.PolyFunctionType+polyFunctionTypeWithTparams :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PolyFunctionType+polyFunctionTypeWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.PolyFunctionType+polyFunctionTypeWithTpe :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.PolyFunctionType+polyFunctionTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PolyFunctionType"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.scala.syntax.PredefString wrapper+predefString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.PredefString+predefString x =+ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+ Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.PredefString"),+ Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.scala.syntax.PrimaryCtor+primaryCtor :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.PrimaryCtor+primaryCtor mods name paramss =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm paramss)}]}))++-- | DSL accessor for the mods field of hydra.scala.syntax.PrimaryCtor+primaryCtorMods :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [Syntax.Mod]+primaryCtorMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.PrimaryCtor+primaryCtorName :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Name+primaryCtorName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramss field of hydra.scala.syntax.PrimaryCtor+primaryCtorParamss :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [[Syntax.ParamData]]+primaryCtorParamss x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the mods field of hydra.scala.syntax.PrimaryCtor+primaryCtorWithMods :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.PrimaryCtor+primaryCtorWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.PrimaryCtor+primaryCtorWithName :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PrimaryCtor+primaryCtorWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramss field of hydra.scala.syntax.PrimaryCtor+primaryCtorWithParamss :: Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.PrimaryCtor+primaryCtorWithParamss original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrimaryCtor"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.PrivateMod+privateMod :: Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.PrivateMod+privateMod within =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrivateMod"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "within"),+ Core.fieldTerm = (Typed.unTypedTerm within)}]}))++-- | DSL updater for the within field of hydra.scala.syntax.PrivateMod+privateModWithWithin :: Typed.TypedTerm Syntax.PrivateMod -> Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.PrivateMod+privateModWithWithin original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.PrivateMod"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "within"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the within field of hydra.scala.syntax.PrivateMod+privateModWithin :: Typed.TypedTerm Syntax.PrivateMod -> Typed.TypedTerm Syntax.Ref+privateModWithin x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.PrivateMod"),+ Core.projectionFieldName = (Core.Name "within")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.scala.syntax.ProjectType+projectType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.ProjectType+projectType qual name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Typed.unTypedTerm qual)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.ProjectType+projectTypeName :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.NameType+projectTypeName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the qual field of hydra.scala.syntax.ProjectType+projectTypeQual :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.Type+projectTypeQual x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),+ Core.projectionFieldName = (Core.Name "qual")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.ProjectType+projectTypeWithName :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.ProjectType+projectTypeWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),+ Core.projectionFieldName = (Core.Name "qual")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the qual field of hydra.scala.syntax.ProjectType+projectTypeWithQual :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ProjectType+projectTypeWithQual original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProjectType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ProtectedMod+protectedMod :: Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.ProtectedMod+protectedMod within =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProtectedMod"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "within"),+ Core.fieldTerm = (Typed.unTypedTerm within)}]}))++-- | DSL updater for the within field of hydra.scala.syntax.ProtectedMod+protectedModWithWithin :: Typed.TypedTerm Syntax.ProtectedMod -> Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.ProtectedMod+protectedModWithWithin original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ProtectedMod"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "within"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the within field of hydra.scala.syntax.ProtectedMod+protectedModWithin :: Typed.TypedTerm Syntax.ProtectedMod -> Typed.TypedTerm Syntax.Ref+protectedModWithin x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ProtectedMod"),+ Core.projectionFieldName = (Core.Name "within")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL injection for the anonymous variant of hydra.scala.syntax.RefData+refDataAnonymous :: Typed.TypedTerm Syntax.AnonymousData -> Typed.TypedTerm Syntax.RefData+refDataAnonymous x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "anonymous"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the applyUnary variant of hydra.scala.syntax.RefData+refDataApplyUnary :: Typed.TypedTerm Syntax.ApplyUnaryData -> Typed.TypedTerm Syntax.RefData+refDataApplyUnary x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "applyUnary"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the name variant of hydra.scala.syntax.RefData+refDataName :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.RefData+refDataName x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the select variant of hydra.scala.syntax.RefData+refDataSelect :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.RefData+refDataSelect x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "select"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the super variant of hydra.scala.syntax.RefData+refDataSuper :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.RefData+refDataSuper x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "super"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the this variant of hydra.scala.syntax.RefData+refDataThis :: Typed.TypedTerm Syntax.ThisData -> Typed.TypedTerm Syntax.RefData+refDataThis x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefData"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "this"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the init variant of hydra.scala.syntax.Ref+refInit :: Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.Ref+refInit x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Ref"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the name variant of hydra.scala.syntax.Ref+refName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Ref+refName x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Ref"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the name variant of hydra.scala.syntax.RefType+refTypeName :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.RefType+refTypeName x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefType"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the project variant of hydra.scala.syntax.RefType+refTypeProject :: Typed.TypedTerm Syntax.ProjectType -> Typed.TypedTerm Syntax.RefType+refTypeProject x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefType"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "project"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the select variant of hydra.scala.syntax.RefType+refTypeSelect :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.RefType+refTypeSelect x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefType"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "select"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the singleton variant of hydra.scala.syntax.RefType+refTypeSingleton :: Typed.TypedTerm Syntax.SingletonType -> Typed.TypedTerm Syntax.RefType+refTypeSingleton x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.RefType"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "singleton"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.RefineType+refineType :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.RefineType+refineType tpe stats =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RefineType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm stats)}]}))++-- | DSL accessor for the stats field of hydra.scala.syntax.RefineType+refineTypeStats :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm [Syntax.Stat]+refineTypeStats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RefineType"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.RefineType+refineTypeTpe :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm (Maybe Syntax.Type)+refineTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RefineType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the stats field of hydra.scala.syntax.RefineType+refineTypeWithStats :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.RefineType+refineTypeWithStats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RefineType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RefineType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tpe field of hydra.scala.syntax.RefineType+refineTypeWithTpe :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.RefineType+refineTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RefineType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RefineType"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.RenameImportee+renameImportee :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RenameImportee+renameImportee name rename =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "rename"),+ Core.fieldTerm = (Typed.unTypedTerm rename)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.RenameImportee+renameImporteeName :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Name+renameImporteeName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rename field of hydra.scala.syntax.RenameImportee+renameImporteeRename :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Name+renameImporteeRename x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),+ Core.projectionFieldName = (Core.Name "rename")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.RenameImportee+renameImporteeWithName :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RenameImportee+renameImporteeWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rename"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),+ Core.projectionFieldName = (Core.Name "rename")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rename field of hydra.scala.syntax.RenameImportee+renameImporteeWithRename :: Typed.TypedTerm Syntax.RenameImportee -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RenameImportee+renameImporteeWithRename original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RenameImportee"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rename"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.RepeatedData+repeatedData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.RepeatedData+repeatedData expr =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)}]}))++-- | DSL accessor for the expr field of hydra.scala.syntax.RepeatedData+repeatedDataExpr :: Typed.TypedTerm Syntax.RepeatedData -> Typed.TypedTerm Syntax.Data+repeatedDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expr field of hydra.scala.syntax.RepeatedData+repeatedDataWithExpr :: Typed.TypedTerm Syntax.RepeatedData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.RepeatedData+repeatedDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.RepeatedEnumCaseDefn+repeatedEnumCaseDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.NameData] -> Typed.TypedTerm Syntax.RepeatedEnumCaseDefn+repeatedEnumCaseDefn mods cases =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Typed.unTypedTerm cases)}]}))++-- | DSL accessor for the cases field of hydra.scala.syntax.RepeatedEnumCaseDefn+repeatedEnumCaseDefnCases :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm [Syntax.NameData]+repeatedEnumCaseDefnCases x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "cases")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.RepeatedEnumCaseDefn+repeatedEnumCaseDefnMods :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm [Syntax.Mod]+repeatedEnumCaseDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the cases field of hydra.scala.syntax.RepeatedEnumCaseDefn+repeatedEnumCaseDefnWithCases :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm [Syntax.NameData] -> Typed.TypedTerm Syntax.RepeatedEnumCaseDefn+repeatedEnumCaseDefnWithCases original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.RepeatedEnumCaseDefn+repeatedEnumCaseDefnWithMods :: Typed.TypedTerm Syntax.RepeatedEnumCaseDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.RepeatedEnumCaseDefn+repeatedEnumCaseDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "cases"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"),+ Core.projectionFieldName = (Core.Name "cases")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.RepeatedPat+repeatedPat :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.RepeatedPat+repeatedPat name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.RepeatedPat+repeatedPatName :: Typed.TypedTerm Syntax.RepeatedPat -> Typed.TypedTerm Syntax.NameData+repeatedPatName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedPat"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.RepeatedPat+repeatedPatWithName :: Typed.TypedTerm Syntax.RepeatedPat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.RepeatedPat+repeatedPatWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.RepeatedType+repeatedType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RepeatedType+repeatedType tpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm tpe)}]}))++-- | DSL accessor for the tpe field of hydra.scala.syntax.RepeatedType+repeatedTypeTpe :: Typed.TypedTerm Syntax.RepeatedType -> Typed.TypedTerm Syntax.Type+repeatedTypeTpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.RepeatedType"),+ Core.projectionFieldName = (Core.Name "tpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the tpe field of hydra.scala.syntax.RepeatedType+repeatedTypeWithTpe :: Typed.TypedTerm Syntax.RepeatedType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RepeatedType+repeatedTypeWithTpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.RepeatedType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "tpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ReturnData+returnData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ReturnData+returnData expr =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ReturnData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)}]}))++-- | DSL accessor for the expr field of hydra.scala.syntax.ReturnData+returnDataExpr :: Typed.TypedTerm Syntax.ReturnData -> Typed.TypedTerm Syntax.Data+returnDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ReturnData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expr field of hydra.scala.syntax.ReturnData+returnDataWithExpr :: Typed.TypedTerm Syntax.ReturnData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ReturnData+returnDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ReturnData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ScalaSymbol+scalaSymbol :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ScalaSymbol+scalaSymbol name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ScalaSymbol"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.ScalaSymbol+scalaSymbolName :: Typed.TypedTerm Syntax.ScalaSymbol -> Typed.TypedTerm String+scalaSymbolName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ScalaSymbol"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.ScalaSymbol+scalaSymbolWithName :: Typed.TypedTerm Syntax.ScalaSymbol -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.ScalaSymbol+scalaSymbolWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ScalaSymbol"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.SecondaryCtor+secondaryCtor :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.Init -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.SecondaryCtor+secondaryCtor mods name paramss init stats =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm paramss)},+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Typed.unTypedTerm init)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm stats)}]}))++-- | DSL accessor for the init field of hydra.scala.syntax.SecondaryCtor+secondaryCtorInit :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Init+secondaryCtorInit x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "init")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.SecondaryCtor+secondaryCtorMods :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [Syntax.Mod]+secondaryCtorMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.SecondaryCtor+secondaryCtorName :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Name+secondaryCtorName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the paramss field of hydra.scala.syntax.SecondaryCtor+secondaryCtorParamss :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [[Syntax.ParamData]]+secondaryCtorParamss x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the stats field of hydra.scala.syntax.SecondaryCtor+secondaryCtorStats :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [Syntax.Stat]+secondaryCtorStats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the init field of hydra.scala.syntax.SecondaryCtor+secondaryCtorWithInit :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Init -> Typed.TypedTerm Syntax.SecondaryCtor+secondaryCtorWithInit original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.SecondaryCtor+secondaryCtorWithMods :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.SecondaryCtor+secondaryCtorWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "init")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.SecondaryCtor+secondaryCtorWithName :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SecondaryCtor+secondaryCtorWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "init")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the paramss field of hydra.scala.syntax.SecondaryCtor+secondaryCtorWithParamss :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [[Syntax.ParamData]] -> Typed.TypedTerm Syntax.SecondaryCtor+secondaryCtorWithParamss original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "init")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the stats field of hydra.scala.syntax.SecondaryCtor+secondaryCtorWithStats :: Typed.TypedTerm Syntax.SecondaryCtor -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.SecondaryCtor+secondaryCtorWithStats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "paramss"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "paramss")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "init"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SecondaryCtor"),+ Core.projectionFieldName = (Core.Name "init")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.SelectData+selectData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.SelectData+selectData qual name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Typed.unTypedTerm qual)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.SelectData+selectDataName :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.NameData+selectDataName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectData"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the qual field of hydra.scala.syntax.SelectData+selectDataQual :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.Data+selectDataQual x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectData"),+ Core.projectionFieldName = (Core.Name "qual")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.SelectData+selectDataWithName :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.SelectData+selectDataWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectData"),+ Core.projectionFieldName = (Core.Name "qual")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the qual field of hydra.scala.syntax.SelectData+selectDataWithQual :: Typed.TypedTerm Syntax.SelectData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.SelectData+selectDataWithQual original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectData"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.SelectType+selectType :: Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.SelectType+selectType qual name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Typed.unTypedTerm qual)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.SelectType+selectTypeName :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.NameType+selectTypeName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the qual field of hydra.scala.syntax.SelectType+selectTypeQual :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.RefData+selectTypeQual x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectType"),+ Core.projectionFieldName = (Core.Name "qual")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.SelectType+selectTypeWithName :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.SelectType+selectTypeWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectType"),+ Core.projectionFieldName = (Core.Name "qual")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the qual field of hydra.scala.syntax.SelectType+selectTypeWithQual :: Typed.TypedTerm Syntax.SelectType -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.SelectType+selectTypeWithQual original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SelectType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "qual"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SelectType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.scala.syntax.Self wrapper+self :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.Self+self x =+ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+ Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.Self"),+ Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.scala.syntax.SingletonType+singletonType :: Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.SingletonType+singletonType ref =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SingletonType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm ref)}]}))++-- | DSL accessor for the ref field of hydra.scala.syntax.SingletonType+singletonTypeRef :: Typed.TypedTerm Syntax.SingletonType -> Typed.TypedTerm Syntax.RefData+singletonTypeRef x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SingletonType"),+ Core.projectionFieldName = (Core.Name "ref")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the ref field of hydra.scala.syntax.SingletonType+singletonTypeWithRef :: Typed.TypedTerm Syntax.SingletonType -> Typed.TypedTerm Syntax.RefData -> Typed.TypedTerm Syntax.SingletonType+singletonTypeWithRef original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SingletonType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.Source+source :: Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Source+source stats =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Source"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm stats)}]}))++-- | DSL accessor for the stats field of hydra.scala.syntax.Source+sourceStats :: Typed.TypedTerm Syntax.Source -> Typed.TypedTerm [Syntax.Stat]+sourceStats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Source"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the stats field of hydra.scala.syntax.Source+sourceWithStats :: Typed.TypedTerm Syntax.Source -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Source+sourceWithStats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Source"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the decl variant of hydra.scala.syntax.Stat+statDecl :: Typed.TypedTerm Syntax.Decl -> Typed.TypedTerm Syntax.Stat+statDecl x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Stat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "decl"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the defn variant of hydra.scala.syntax.Stat+statDefn :: Typed.TypedTerm Syntax.Defn -> Typed.TypedTerm Syntax.Stat+statDefn x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Stat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "defn"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the importExport variant of hydra.scala.syntax.Stat+statImportExport :: Typed.TypedTerm Syntax.ImportExportStat -> Typed.TypedTerm Syntax.Stat+statImportExport x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Stat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "importExport"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the term variant of hydra.scala.syntax.Stat+statTerm :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Stat+statTerm x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Stat"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "term"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.SuperData+superData :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SuperData+superData thisp superp =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SuperData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "thisp"),+ Core.fieldTerm = (Typed.unTypedTerm thisp)},+ Core.Field {+ Core.fieldName = (Core.Name "superp"),+ Core.fieldTerm = (Typed.unTypedTerm superp)}]}))++-- | DSL accessor for the superp field of hydra.scala.syntax.SuperData+superDataSuperp :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.Name+superDataSuperp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SuperData"),+ Core.projectionFieldName = (Core.Name "superp")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the thisp field of hydra.scala.syntax.SuperData+superDataThisp :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.Name+superDataThisp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SuperData"),+ Core.projectionFieldName = (Core.Name "thisp")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the superp field of hydra.scala.syntax.SuperData+superDataWithSuperp :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SuperData+superDataWithSuperp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SuperData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "thisp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SuperData"),+ Core.projectionFieldName = (Core.Name "thisp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "superp"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the thisp field of hydra.scala.syntax.SuperData+superDataWithThisp :: Typed.TypedTerm Syntax.SuperData -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SuperData+superDataWithThisp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.SuperData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "thisp"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "superp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.SuperData"),+ Core.projectionFieldName = (Core.Name "superp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.Template+template :: Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm [Syntax.Init] -> Typed.TypedTerm Syntax.Self -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Template+template early inits self stats =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "early"),+ Core.fieldTerm = (Typed.unTypedTerm early)},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Typed.unTypedTerm inits)},+ Core.Field {+ Core.fieldName = (Core.Name "self"),+ Core.fieldTerm = (Typed.unTypedTerm self)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm stats)}]}))++-- | DSL accessor for the early field of hydra.scala.syntax.Template+templateEarly :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Stat]+templateEarly x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "early")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the inits field of hydra.scala.syntax.Template+templateInits :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Init]+templateInits x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the self field of hydra.scala.syntax.Template+templateSelf :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.Self+templateSelf x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "self")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the stats field of hydra.scala.syntax.Template+templateStats :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Stat]+templateStats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the early field of hydra.scala.syntax.Template+templateWithEarly :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Template+templateWithEarly original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "early"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "self"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "self")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the inits field of hydra.scala.syntax.Template+templateWithInits :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Init] -> Typed.TypedTerm Syntax.Template+templateWithInits original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "early"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "early")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "self"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "self")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the self field of hydra.scala.syntax.Template+templateWithSelf :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.Self -> Typed.TypedTerm Syntax.Template+templateWithSelf original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "early"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "early")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "self"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "stats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the stats field of hydra.scala.syntax.Template+templateWithStats :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm [Syntax.Stat] -> Typed.TypedTerm Syntax.Template+templateWithStats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "early"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "early")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "inits"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "inits")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "self"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.Template"),+ Core.projectionFieldName = (Core.Name "self")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "stats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for the hydra.scala.syntax.ThisData wrapper+thisData :: Typed.TypedTerm () -> Typed.TypedTerm Syntax.ThisData+thisData x =+ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+ Core.wrappedTermTypeName = (Core.Name "hydra.scala.syntax.ThisData"),+ Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.scala.syntax.ThrowData+throwData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ThrowData+throwData expr =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ThrowData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)}]}))++-- | DSL accessor for the expr field of hydra.scala.syntax.ThrowData+throwDataExpr :: Typed.TypedTerm Syntax.ThrowData -> Typed.TypedTerm Syntax.Data+throwDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ThrowData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the expr field of hydra.scala.syntax.ThrowData+throwDataWithExpr :: Typed.TypedTerm Syntax.ThrowData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ThrowData+throwDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ThrowData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.TraitDefn+traitDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.TraitDefn+traitDefn mods name tparams ctor template =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm ctor)},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm template)}]}))++-- | DSL accessor for the ctor field of hydra.scala.syntax.TraitDefn+traitDefnCtor :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.PrimaryCtor+traitDefnCtor x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.TraitDefn+traitDefnMods :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm [Syntax.Mod]+traitDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.TraitDefn+traitDefnName :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.NameType+traitDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the template field of hydra.scala.syntax.TraitDefn+traitDefnTemplate :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.Template+traitDefnTemplate x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.TraitDefn+traitDefnTparams :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm [Syntax.ParamType]+traitDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the ctor field of hydra.scala.syntax.TraitDefn+traitDefnWithCtor :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.PrimaryCtor -> Typed.TypedTerm Syntax.TraitDefn+traitDefnWithCtor original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.TraitDefn+traitDefnWithMods :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.TraitDefn+traitDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.TraitDefn+traitDefnWithName :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TraitDefn+traitDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the template field of hydra.scala.syntax.TraitDefn+traitDefnWithTemplate :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.TraitDefn+traitDefnWithTemplate original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.TraitDefn+traitDefnWithTparams :: Typed.TypedTerm Syntax.TraitDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.TraitDefn+traitDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "ctor")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TraitDefn"),+ Core.projectionFieldName = (Core.Name "template")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the bounds variant of hydra.scala.syntax.Tree+treeBounds :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.Tree+treeBounds x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "bounds"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the caseTree variant of hydra.scala.syntax.Tree+treeCaseTree :: Typed.TypedTerm Syntax.CaseTree -> Typed.TypedTerm Syntax.Tree+treeCaseTree x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "caseTree"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the ctor variant of hydra.scala.syntax.Tree+treeCtor :: Typed.TypedTerm Syntax.Ctor -> Typed.TypedTerm Syntax.Tree+treeCtor x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "ctor"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the enumerator variant of hydra.scala.syntax.Tree+treeEnumerator :: Typed.TypedTerm Syntax.Enumerator -> Typed.TypedTerm Syntax.Tree+treeEnumerator x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "enumerator"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the importee variant of hydra.scala.syntax.Tree+treeImportee :: Typed.TypedTerm Syntax.Importee -> Typed.TypedTerm Syntax.Tree+treeImportee x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "importee"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the importer variant of hydra.scala.syntax.Tree+treeImporter :: Typed.TypedTerm Syntax.Importer -> Typed.TypedTerm Syntax.Tree+treeImporter x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "importer"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the member variant of hydra.scala.syntax.Tree+treeMember :: Typed.TypedTerm Syntax.Member -> Typed.TypedTerm Syntax.Tree+treeMember x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "member"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the mod variant of hydra.scala.syntax.Tree+treeMod :: Typed.TypedTerm Syntax.Mod -> Typed.TypedTerm Syntax.Tree+treeMod x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "mod"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the pat variant of hydra.scala.syntax.Tree+treePat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Tree+treePat x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the ref variant of hydra.scala.syntax.Tree+treeRef :: Typed.TypedTerm Syntax.Ref -> Typed.TypedTerm Syntax.Tree+treeRef x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the source variant of hydra.scala.syntax.Tree+treeSource :: Typed.TypedTerm Syntax.Source -> Typed.TypedTerm Syntax.Tree+treeSource x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "source"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the stat variant of hydra.scala.syntax.Tree+treeStat :: Typed.TypedTerm Syntax.Stat -> Typed.TypedTerm Syntax.Tree+treeStat x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "stat"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the template variant of hydra.scala.syntax.Tree+treeTemplate :: Typed.TypedTerm Syntax.Template -> Typed.TypedTerm Syntax.Tree+treeTemplate x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "template"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the type variant of hydra.scala.syntax.Tree+treeType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Tree+treeType x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Tree"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "type"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.TryData+tryData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.TryData+tryData expr catchp finallyp =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)},+ Core.Field {+ Core.fieldName = (Core.Name "catchp"),+ Core.fieldTerm = (Typed.unTypedTerm catchp)},+ Core.Field {+ Core.fieldName = (Core.Name "finallyp"),+ Core.fieldTerm = (Typed.unTypedTerm finallyp)}]}))++-- | DSL accessor for the catchp field of hydra.scala.syntax.TryData+tryDataCatchp :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm [Syntax.Case]+tryDataCatchp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "catchp")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expr field of hydra.scala.syntax.TryData+tryDataExpr :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm Syntax.Data+tryDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the finallyp field of hydra.scala.syntax.TryData+tryDataFinallyp :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm (Maybe Syntax.Data)+tryDataFinallyp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "finallyp")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the catchp field of hydra.scala.syntax.TryData+tryDataWithCatchp :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm [Syntax.Case] -> Typed.TypedTerm Syntax.TryData+tryDataWithCatchp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "catchp"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "finallyp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "finallyp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the expr field of hydra.scala.syntax.TryData+tryDataWithExpr :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.TryData+tryDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "catchp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "catchp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "finallyp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "finallyp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the finallyp field of hydra.scala.syntax.TryData+tryDataWithFinallyp :: Typed.TypedTerm Syntax.TryData -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.TryData+tryDataWithFinallyp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "catchp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryData"),+ Core.projectionFieldName = (Core.Name "catchp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "finallyp"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.TryWithHandlerData+tryWithHandlerData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.TryWithHandlerData+tryWithHandlerData expr catchp finallyp =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)},+ Core.Field {+ Core.fieldName = (Core.Name "catchp"),+ Core.fieldTerm = (Typed.unTypedTerm catchp)},+ Core.Field {+ Core.fieldName = (Core.Name "finallyp"),+ Core.fieldTerm = (Typed.unTypedTerm finallyp)}]}))++-- | DSL accessor for the catchp field of hydra.scala.syntax.TryWithHandlerData+tryWithHandlerDataCatchp :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data+tryWithHandlerDataCatchp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "catchp")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expr field of hydra.scala.syntax.TryWithHandlerData+tryWithHandlerDataExpr :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data+tryWithHandlerDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the finallyp field of hydra.scala.syntax.TryWithHandlerData+tryWithHandlerDataFinallyp :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm (Maybe Syntax.Data)+tryWithHandlerDataFinallyp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "finallyp")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the catchp field of hydra.scala.syntax.TryWithHandlerData+tryWithHandlerDataWithCatchp :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.TryWithHandlerData+tryWithHandlerDataWithCatchp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "catchp"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "finallyp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "finallyp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the expr field of hydra.scala.syntax.TryWithHandlerData+tryWithHandlerDataWithExpr :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.TryWithHandlerData+tryWithHandlerDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "catchp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "catchp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "finallyp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "finallyp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the finallyp field of hydra.scala.syntax.TryWithHandlerData+tryWithHandlerDataWithFinallyp :: Typed.TypedTerm Syntax.TryWithHandlerData -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.TryWithHandlerData+tryWithHandlerDataWithFinallyp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "catchp"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TryWithHandlerData"),+ Core.projectionFieldName = (Core.Name "catchp")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "finallyp"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.TupleData+tupleData :: Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.TupleData+tupleData args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TupleData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.TupleData+tupleDataArgs :: Typed.TypedTerm Syntax.TupleData -> Typed.TypedTerm [Syntax.Data]+tupleDataArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TupleData"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.TupleData+tupleDataWithArgs :: Typed.TypedTerm Syntax.TupleData -> Typed.TypedTerm [Syntax.Data] -> Typed.TypedTerm Syntax.TupleData+tupleDataWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TupleData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.TuplePat+tuplePat :: Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.TuplePat+tuplePat args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TuplePat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.TuplePat+tuplePatArgs :: Typed.TypedTerm Syntax.TuplePat -> Typed.TypedTerm [Syntax.Pat]+tuplePatArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TuplePat"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.TuplePat+tuplePatWithArgs :: Typed.TypedTerm Syntax.TuplePat -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.TuplePat+tuplePatWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TuplePat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.TupleType+tupleType :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.TupleType+tupleType args =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TupleType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm args)}]}))++-- | DSL accessor for the args field of hydra.scala.syntax.TupleType+tupleTypeArgs :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm [Syntax.Type]+tupleTypeArgs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TupleType"),+ Core.projectionFieldName = (Core.Name "args")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the args field of hydra.scala.syntax.TupleType+tupleTypeWithArgs :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.TupleType+tupleTypeWithArgs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TupleType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "args"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the and variant of hydra.scala.syntax.Type+typeAnd :: Typed.TypedTerm Syntax.AndType -> Typed.TypedTerm Syntax.Type+typeAnd x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "and"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the annotate variant of hydra.scala.syntax.Type+typeAnnotate :: Typed.TypedTerm Syntax.AnnotateType -> Typed.TypedTerm Syntax.Type+typeAnnotate x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "annotate"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the anonymousName variant of hydra.scala.syntax.Type+typeAnonymousName :: Typed.TypedTerm Syntax.AnonymousNameType -> Typed.TypedTerm Syntax.Type+typeAnonymousName x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "anonymousName"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the apply variant of hydra.scala.syntax.Type+typeApply :: Typed.TypedTerm Syntax.ApplyType -> Typed.TypedTerm Syntax.Type+typeApply x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "apply"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the applyInfix variant of hydra.scala.syntax.Type+typeApplyInfix :: Typed.TypedTerm Syntax.ApplyInfixType -> Typed.TypedTerm Syntax.Type+typeApplyInfix x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "applyInfix"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.TypeBounds+typeBounds :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.TypeBounds+typeBounds lo hi =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lo"),+ Core.fieldTerm = (Typed.unTypedTerm lo)},+ Core.Field {+ Core.fieldName = (Core.Name "hi"),+ Core.fieldTerm = (Typed.unTypedTerm hi)}]}))++-- | DSL accessor for the hi field of hydra.scala.syntax.TypeBounds+typeBoundsHi :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm (Maybe Syntax.Type)+typeBoundsHi x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),+ Core.projectionFieldName = (Core.Name "hi")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the lo field of hydra.scala.syntax.TypeBounds+typeBoundsLo :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm (Maybe Syntax.Type)+typeBoundsLo x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),+ Core.projectionFieldName = (Core.Name "lo")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the hi field of hydra.scala.syntax.TypeBounds+typeBoundsWithHi :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.TypeBounds+typeBoundsWithHi original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lo"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),+ Core.projectionFieldName = (Core.Name "lo")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "hi"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the lo field of hydra.scala.syntax.TypeBounds+typeBoundsWithLo :: Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.TypeBounds+typeBoundsWithLo original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lo"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "hi"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeBounds"),+ Core.projectionFieldName = (Core.Name "hi")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the byName variant of hydra.scala.syntax.Type+typeByName :: Typed.TypedTerm Syntax.ByNameType -> Typed.TypedTerm Syntax.Type+typeByName x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "byName"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.TypeCase+typeCase :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeCase+typeCase pat body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm pat)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.TypeCase+typeCaseBody :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.Type+typeCaseBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the pat field of hydra.scala.syntax.TypeCase+typeCasePat :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.Type+typeCasePat x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.TypeCase+typeCaseWithBody :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeCase+typeCaseWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the pat field of hydra.scala.syntax.TypeCase+typeCaseWithPat :: Typed.TypedTerm Syntax.TypeCase -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeCase+typeCaseWithPat original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeCase"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the contextFunction variant of hydra.scala.syntax.Type+typeContextFunction :: Typed.TypedTerm Syntax.ContextFunctionType -> Typed.TypedTerm Syntax.Type+typeContextFunction x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "contextFunction"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.TypeDecl+typeDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.TypeDecl+typeDecl mods name tparams bounds =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "bounds"),+ Core.fieldTerm = (Typed.unTypedTerm bounds)}]}))++-- | DSL accessor for the bounds field of hydra.scala.syntax.TypeDecl+typeDeclBounds :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.TypeBounds+typeDeclBounds x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "bounds")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.TypeDecl+typeDeclMods :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.Mod]+typeDeclMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.TypeDecl+typeDeclName :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.NameType+typeDeclName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.TypeDecl+typeDeclTparams :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.ParamType]+typeDeclTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the bounds field of hydra.scala.syntax.TypeDecl+typeDeclWithBounds :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.TypeBounds -> Typed.TypedTerm Syntax.TypeDecl+typeDeclWithBounds original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "bounds"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.TypeDecl+typeDeclWithMods :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.TypeDecl+typeDeclWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "bounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "bounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.TypeDecl+typeDeclWithName :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TypeDecl+typeDeclWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "bounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "bounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.TypeDecl+typeDeclWithTparams :: Typed.TypedTerm Syntax.TypeDecl -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.TypeDecl+typeDeclWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "bounds"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDecl"),+ Core.projectionFieldName = (Core.Name "bounds")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.TypeDefn+typeDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeDefn+typeDefn mods name tparams body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm tparams)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.TypeDefn+typeDefnBody :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.Type+typeDefnBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.TypeDefn+typeDefnMods :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm [Syntax.Mod]+typeDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.scala.syntax.TypeDefn+typeDefnName :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.NameType+typeDefnName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the tparams field of hydra.scala.syntax.TypeDefn+typeDefnTparams :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm [Syntax.ParamType]+typeDefnTparams x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.TypeDefn+typeDefnWithBody :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeDefn+typeDefnWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.TypeDefn+typeDefnWithMods :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.TypeDefn+typeDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.scala.syntax.TypeDefn+typeDefnWithName :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TypeDefn+typeDefnWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "tparams")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the tparams field of hydra.scala.syntax.TypeDefn+typeDefnWithTparams :: Typed.TypedTerm Syntax.TypeDefn -> Typed.TypedTerm [Syntax.ParamType] -> Typed.TypedTerm Syntax.TypeDefn+typeDefnWithTparams original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "tparams"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeDefn"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the existential variant of hydra.scala.syntax.Type+typeExistential :: Typed.TypedTerm Syntax.ExistentialType -> Typed.TypedTerm Syntax.Type+typeExistential x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "existential"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the function variant of hydra.scala.syntax.Type+typeFunction :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type+typeFunction x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "function"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the implicitFunction variant of hydra.scala.syntax.Type+typeImplicitFunction :: Typed.TypedTerm Syntax.ImplicitFunctionType -> Typed.TypedTerm Syntax.Type+typeImplicitFunction x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "implicitFunction"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the lambda variant of hydra.scala.syntax.Type+typeLambda :: Typed.TypedTerm Syntax.LambdaType -> Typed.TypedTerm Syntax.Type+typeLambda x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "lambda"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the match variant of hydra.scala.syntax.Type+typeMatch :: Typed.TypedTerm Syntax.MatchType -> Typed.TypedTerm Syntax.Type+typeMatch x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "match"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.TypeMember+typeMember :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TypeMember+typeMember name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeMember"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.TypeMember+typeMemberName :: Typed.TypedTerm Syntax.TypeMember -> Typed.TypedTerm Syntax.NameType+typeMemberName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypeMember"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.TypeMember+typeMemberWithName :: Typed.TypedTerm Syntax.TypeMember -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.TypeMember+typeMemberWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypeMember"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the method variant of hydra.scala.syntax.Type+typeMethod :: Typed.TypedTerm Syntax.MethodType -> Typed.TypedTerm Syntax.Type+typeMethod x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "method"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the or variant of hydra.scala.syntax.Type+typeOr :: Typed.TypedTerm Syntax.OrType -> Typed.TypedTerm Syntax.Type+typeOr x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "or"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the placeholder variant of hydra.scala.syntax.Type+typePlaceholder :: Typed.TypedTerm Syntax.PlaceholderType -> Typed.TypedTerm Syntax.Type+typePlaceholder x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "placeholder"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the polyFunction variant of hydra.scala.syntax.Type+typePolyFunction :: Typed.TypedTerm Syntax.PolyFunctionType -> Typed.TypedTerm Syntax.Type+typePolyFunction x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "polyFunction"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the ref variant of hydra.scala.syntax.Type+typeRef :: Typed.TypedTerm Syntax.RefType -> Typed.TypedTerm Syntax.Type+typeRef x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "ref"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the refine variant of hydra.scala.syntax.Type+typeRefine :: Typed.TypedTerm Syntax.RefineType -> Typed.TypedTerm Syntax.Type+typeRefine x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "refine"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the repeated variant of hydra.scala.syntax.Type+typeRepeated :: Typed.TypedTerm Syntax.RepeatedType -> Typed.TypedTerm Syntax.Type+typeRepeated x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "repeated"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the tuple variant of hydra.scala.syntax.Type+typeTuple :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm Syntax.Type+typeTuple x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "tuple"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the typedParam variant of hydra.scala.syntax.Type+typeTypedParam :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Type+typeTypedParam x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "typedParam"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the var variant of hydra.scala.syntax.Type+typeVar :: Typed.TypedTerm Syntax.VarType -> Typed.TypedTerm Syntax.Type+typeVar x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "var"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL injection for the with variant of hydra.scala.syntax.Type+typeWith :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type+typeWith x =+ Typed.TypedTerm (Core.TermInject (Core.Injection {+ Core.injectionTypeName = (Core.Name "hydra.scala.syntax.Type"),+ Core.injectionField = Core.Field {+ Core.fieldName = (Core.Name "with"),+ Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.scala.syntax.TypedParamType+typedParamType :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedParamType+typedParamType name typ =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)},+ Core.Field {+ Core.fieldName = (Core.Name "typ"),+ Core.fieldTerm = (Typed.unTypedTerm typ)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.TypedParamType+typedParamTypeName :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Name+typedParamTypeName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the typ field of hydra.scala.syntax.TypedParamType+typedParamTypeTyp :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Type+typedParamTypeTyp x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),+ Core.projectionFieldName = (Core.Name "typ")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.TypedParamType+typedParamTypeWithName :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TypedParamType+typedParamTypeWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "typ"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),+ Core.projectionFieldName = (Core.Name "typ")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the typ field of hydra.scala.syntax.TypedParamType+typedParamTypeWithTyp :: Typed.TypedTerm Syntax.TypedParamType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedParamType+typedParamTypeWithTyp original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedParamType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "typ"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.TypedPat+typedPat :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedPat+typedPat lhs rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.TypedPat+typedPatLhs :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Pat+typedPatLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.TypedPat+typedPatRhs :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Type+typedPatRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.TypedPat+typedPatWithLhs :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.TypedPat+typedPatWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.TypedPat+typedPatWithRhs :: Typed.TypedTerm Syntax.TypedPat -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedPat+typedPatWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.TypedPat"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the body of hydra.scala.syntax.AnonymousData+unAnonymousData :: Typed.TypedTerm Syntax.AnonymousData -> Typed.TypedTerm ()+unAnonymousData x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.AnonymousData")),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.scala.syntax.AnonymousNameType+unAnonymousNameType :: Typed.TypedTerm Syntax.AnonymousNameType -> Typed.TypedTerm ()+unAnonymousNameType x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.AnonymousNameType")),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.scala.syntax.PredefString+unPredefString :: Typed.TypedTerm Syntax.PredefString -> Typed.TypedTerm String+unPredefString x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.PredefString")),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.scala.syntax.Self+unSelf :: Typed.TypedTerm Syntax.Self -> Typed.TypedTerm ()+unSelf x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.Self")),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.scala.syntax.ThisData+unThisData :: Typed.TypedTerm Syntax.ThisData -> Typed.TypedTerm ()+unThisData x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.scala.syntax.ThisData")),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL constructor for hydra.scala.syntax.UnimportImportee+unimportImportee :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.UnimportImportee+unimportImportee name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.UnimportImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.UnimportImportee+unimportImporteeName :: Typed.TypedTerm Syntax.UnimportImportee -> Typed.TypedTerm Syntax.Name+unimportImporteeName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.UnimportImportee"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.UnimportImportee+unimportImporteeWithName :: Typed.TypedTerm Syntax.UnimportImportee -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.UnimportImportee+unimportImporteeWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.UnimportImportee"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ValDecl+valDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ValDecl+valDecl mods pats decltpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Typed.unTypedTerm pats)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)}]}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.ValDecl+valDeclDecltpe :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm Syntax.Type+valDeclDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.ValDecl+valDeclMods :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm [Syntax.Mod]+valDeclMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the pats field of hydra.scala.syntax.ValDecl+valDeclPats :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm [Syntax.Pat]+valDeclPats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.ValDecl+valDeclWithDecltpe :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ValDecl+valDeclWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.ValDecl+valDeclWithMods :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ValDecl+valDeclWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the pats field of hydra.scala.syntax.ValDecl+valDeclWithPats :: Typed.TypedTerm Syntax.ValDecl -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ValDecl+valDeclWithPats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.ValDefn+valDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ValDefn+valDefn mods pats decltpe rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Typed.unTypedTerm pats)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.ValDefn+valDefnDecltpe :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm (Maybe Syntax.Type)+valDefnDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.ValDefn+valDefnMods :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm [Syntax.Mod]+valDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the pats field of hydra.scala.syntax.ValDefn+valDefnPats :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm [Syntax.Pat]+valDefnPats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.ValDefn+valDefnRhs :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm Syntax.Data+valDefnRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.ValDefn+valDefnWithDecltpe :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.ValDefn+valDefnWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.ValDefn+valDefnWithMods :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.ValDefn+valDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the pats field of hydra.scala.syntax.ValDefn+valDefnWithPats :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.ValDefn+valDefnWithPats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.ValDefn+valDefnWithRhs :: Typed.TypedTerm Syntax.ValDefn -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ValDefn+valDefnWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.ValEnumerator+valEnumerator :: Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ValEnumerator+valEnumerator pat rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm pat)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the pat field of hydra.scala.syntax.ValEnumerator+valEnumeratorPat :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Pat+valEnumeratorPat x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.ValEnumerator+valEnumeratorRhs :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Data+valEnumeratorRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the pat field of hydra.scala.syntax.ValEnumerator+valEnumeratorWithPat :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Pat -> Typed.TypedTerm Syntax.ValEnumerator+valEnumeratorWithPat original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.ValEnumerator+valEnumeratorWithRhs :: Typed.TypedTerm Syntax.ValEnumerator -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.ValEnumerator+valEnumeratorWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "pat"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.ValEnumerator"),+ Core.projectionFieldName = (Core.Name "pat")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.VarDecl+varDecl :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VarDecl+varDecl mods pats decltpe =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Typed.unTypedTerm pats)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)}]}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.VarDecl+varDeclDecltpe :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm Syntax.Type+varDeclDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.VarDecl+varDeclMods :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.Mod]+varDeclMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the pats field of hydra.scala.syntax.VarDecl+varDeclPats :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.Pat]+varDeclPats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.VarDecl+varDeclWithDecltpe :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VarDecl+varDeclWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.VarDecl+varDeclWithMods :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.VarDecl+varDeclWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the pats field of hydra.scala.syntax.VarDecl+varDeclWithPats :: Typed.TypedTerm Syntax.VarDecl -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.VarDecl+varDeclWithPats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDecl"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.VarDefn+varDefn :: Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.VarDefn+varDefn mods pats decltpe rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm mods)},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Typed.unTypedTerm pats)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm decltpe)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the decltpe field of hydra.scala.syntax.VarDefn+varDefnDecltpe :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm Syntax.Type+varDefnDecltpe x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mods field of hydra.scala.syntax.VarDefn+varDefnMods :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm [Syntax.Mod]+varDefnMods x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the pats field of hydra.scala.syntax.VarDefn+varDefnPats :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm [Syntax.Pat]+varDefnPats x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.VarDefn+varDefnRhs :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm (Maybe Syntax.Data)+varDefnRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the decltpe field of hydra.scala.syntax.VarDefn+varDefnWithDecltpe :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VarDefn+varDefnWithDecltpe original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mods field of hydra.scala.syntax.VarDefn+varDefnWithMods :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm [Syntax.Mod] -> Typed.TypedTerm Syntax.VarDefn+varDefnWithMods original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the pats field of hydra.scala.syntax.VarDefn+varDefnWithPats :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm [Syntax.Pat] -> Typed.TypedTerm Syntax.VarDefn+varDefnWithPats original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.VarDefn+varDefnWithRhs :: Typed.TypedTerm Syntax.VarDefn -> Typed.TypedTerm (Maybe Syntax.Data) -> Typed.TypedTerm Syntax.VarDefn+varDefnWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "mods"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "mods")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "pats"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "pats")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "decltpe"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarDefn"),+ Core.projectionFieldName = (Core.Name "decltpe")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.VarPat+varPat :: Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.VarPat+varPat name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.VarPat+varPatName :: Typed.TypedTerm Syntax.VarPat -> Typed.TypedTerm Syntax.NameData+varPatName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarPat"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.VarPat+varPatWithName :: Typed.TypedTerm Syntax.VarPat -> Typed.TypedTerm Syntax.NameData -> Typed.TypedTerm Syntax.VarPat+varPatWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarPat"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.VarType+varType :: Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.VarType+varType name =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm name)}]}))++-- | DSL accessor for the name field of hydra.scala.syntax.VarType+varTypeName :: Typed.TypedTerm Syntax.VarType -> Typed.TypedTerm Syntax.NameType+varTypeName x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.VarType"),+ Core.projectionFieldName = (Core.Name "name")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the name field of hydra.scala.syntax.VarType+varTypeWithName :: Typed.TypedTerm Syntax.VarType -> Typed.TypedTerm Syntax.NameType -> Typed.TypedTerm Syntax.VarType+varTypeWithName original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.VarType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "name"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.scala.syntax.WhileData+whileData :: Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.WhileData+whileData expr body =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.WhileData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm expr)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm body)}]}))++-- | DSL accessor for the body field of hydra.scala.syntax.WhileData+whileDataBody :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data+whileDataBody x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WhileData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the expr field of hydra.scala.syntax.WhileData+whileDataExpr :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data+whileDataExpr x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WhileData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the body field of hydra.scala.syntax.WhileData+whileDataWithBody :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.WhileData+whileDataWithBody original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.WhileData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WhileData"),+ Core.projectionFieldName = (Core.Name "expr")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the expr field of hydra.scala.syntax.WhileData+whileDataWithExpr :: Typed.TypedTerm Syntax.WhileData -> Typed.TypedTerm Syntax.Data -> Typed.TypedTerm Syntax.WhileData+whileDataWithExpr original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.WhileData"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "expr"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "body"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WhileData"),+ Core.projectionFieldName = (Core.Name "body")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.scala.syntax.WithType+withType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.WithType+withType lhs rhs =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.WithType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm lhs)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))++-- | DSL accessor for the lhs field of hydra.scala.syntax.WithType+withTypeLhs :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type+withTypeLhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WithType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the rhs field of hydra.scala.syntax.WithType+withTypeRhs :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type+withTypeRhs x =+ Typed.TypedTerm (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WithType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the lhs field of hydra.scala.syntax.WithType+withTypeWithLhs :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.WithType+withTypeWithLhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.WithType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WithType"),+ Core.projectionFieldName = (Core.Name "rhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rhs field of hydra.scala.syntax.WithType+withTypeWithRhs :: Typed.TypedTerm Syntax.WithType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.WithType+withTypeWithRhs original newVal =+ Typed.TypedTerm (Core.TermRecord (Core.Record {+ Core.recordTypeName = (Core.Name "hydra.scala.syntax.WithType"),+ Core.recordFields = [+ Core.Field {+ Core.fieldName = (Core.Name "lhs"),+ Core.fieldTerm = (Core.TermApplication (Core.Application {+ Core.applicationFunction = (Core.TermProject (Core.Projection {+ Core.projectionTypeName = (Core.Name "hydra.scala.syntax.WithType"),+ Core.projectionFieldName = (Core.Name "lhs")})),+ Core.applicationArgument = (Typed.unTypedTerm original)}))},+ Core.Field {+ Core.fieldName = (Core.Name "rhs"),+ Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+ src/main/haskell/Hydra/Scala/Coder.hs view
@@ -0,0 +1,955 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Scala code generator: converts Hydra modules to Scala source code++module Hydra.Scala.Coder where++import qualified Hydra.Analysis as Analysis+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Arity as Arity+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Environment as Environment+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.File as ErrorFile+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Error.System as ErrorSystem+import qualified Hydra.Errors as Errors+import qualified Hydra.File as File+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Inference as Inference+import qualified Hydra.Json.Model as Model+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Overlay.Haskell.Lib.Math as Math+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Predicates as Predicates+import qualified Hydra.Query as Query+import qualified Hydra.Reduction as Reduction+import qualified Hydra.Relational as Relational+import qualified Hydra.Resolution as Resolution+import qualified Hydra.Scala.Language as Language+import qualified Hydra.Scala.Serde as Serde+import qualified Hydra.Scala.Syntax as Syntax+import qualified Hydra.Scala.Utils as Utils+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Serialization as Serialization+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Sorting as Sorting+import qualified Hydra.Strip as Strip+import qualified Hydra.System as System+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Time as Time+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S++-- | Apply a variable to a term, performing substitution for lambdas+applyVar :: Core.Term -> Core.Name -> Core.Term+applyVar fterm avar =++ let v = Core.unName avar+ in case (Strip.deannotateAndDetypeTerm fterm) of+ Core.TermLambda v0 ->+ let lamParam = Core.lambdaParameter v0+ lamBody = Core.lambdaBody v0+ in (Logic.ifElse (Variables.isFreeVariableInTerm lamParam lamBody) lamBody (Variables.substituteVariable lamParam avar lamBody))+ _ -> Core.TermApplication (Core.Application {+ Core.applicationFunction = fterm,+ Core.applicationArgument = (Core.TermVariable avar)})++-- | Construct a Scala package from a Hydra module and its definitions+constructModule :: t0 -> Graph.Graph -> Packaging.Module -> [Packaging.Definition] -> Either Errors.Error Syntax.Pkg+constructModule cx g mod defs =++ let partitioned = Environment.partitionDefinitions defs+ typeDefs = Pairs.first partitioned+ termDefs = Pairs.second partitioned+ nsName = Packaging.unModuleName (Packaging.moduleName mod)+ pname =+ Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." nsName)))}+ pref = Syntax.RefDataName pname+ in (Eithers.bind (Eithers.mapList (\td -> encodeTypeDefinition cx g td) typeDefs) (\typeDeclStats -> Eithers.bind (Eithers.mapList (\td -> encodeTermDefinition cx g td) termDefs) (\termDeclStats -> Eithers.bind (findImports cx g mod) (\imports -> Right (Syntax.Pkg {+ Syntax.pkgName = pname,+ Syntax.pkgRef = pref,+ Syntax.pkgStats = (Lists.concat [+ imports,+ typeDeclStats,+ termDeclStats])})))))++-- | Drop N domain types from a function type, returning the remaining type+dropDomains :: Int -> Core.Type -> Core.Type+dropDomains n t =+ Logic.ifElse (Equality.lte n 0) t (case (Strip.deannotateType t) of+ Core.TypeFunction v0 -> dropDomains (Math.sub n 1) (Core.functionTypeCodomain v0)+ Core.TypeForall v0 -> dropDomains n (Core.forallTypeBody v0)+ _ -> t)++-- | Encode a case branch+encodeCase :: t0 -> Graph.Graph -> M.Map Core.Name Core.Type -> Maybe Core.Name -> Core.CaseAlternative -> Either Errors.Error Syntax.Case+encodeCase cx g ftypes sn f =++ let fname = Core.caseAlternativeName f+ fterm = Core.caseAlternativeHandler f+ isUnit =+ Optionals.cases (Maps.lookup fname ftypes) (case (Strip.deannotateAndDetypeTerm fterm) of+ Core.TermLambda v0 ->+ let lamParam = Core.lambdaParameter v0+ lamBody = Core.lambdaBody v0+ domIsUnit = Optionals.cases (Core.lambdaDomain v0) False (\dom -> Equality.equal dom Core.TypeUnit)+ bodyIgnoresParam = Variables.isFreeVariableInTerm lamParam lamBody+ in (Logic.or domIsUnit bodyIgnoresParam)+ Core.TermRecord v0 -> Equality.equal (Lists.length (Core.recordFields v0)) 0+ Core.TermUnit -> True+ _ -> False) (\dom -> case (Strip.deannotateType dom) of+ Core.TypeUnit -> True+ Core.TypeRecord v0 -> Equality.equal (Lists.length v0) 0+ _ -> False)+ shortTypeName =+ Optionals.fromOptional "x" (Lists.maybeLast (Strings.splitOn "." (Optionals.cases sn "x" (\n -> Core.unName n))))+ lamParamSuffix =+ case (Strip.deannotateAndDetypeTerm fterm) of+ Core.TermLambda v0 ->+ let rawName = Core.unName (Core.lambdaParameter v0)+ safeName = Strings.fromList (Lists.map (\c -> Logic.ifElse (Equality.equal c 39) 95 c) (Strings.toList rawName))+ in (Strings.cat2 "_" safeName)+ _ -> ""+ v =+ Core.Name (Strings.cat [+ "v_",+ shortTypeName,+ "_",+ (Core.unName fname),+ lamParamSuffix])+ domainIsUnit =+ case (Strip.deannotateAndDetypeTerm fterm) of+ Core.TermLambda v0 -> Optionals.cases (Core.lambdaDomain v0) True (\dom -> Equality.equal dom Core.TypeUnit)+ _ -> True+ patArgs = Logic.ifElse isUnit (Logic.ifElse domainIsUnit [] [+ Syntax.PatWildcard]) [+ Utils.svar v]+ pat =+ Syntax.PatExtract (Syntax.ExtractPat {+ Syntax.extractPatFun = (Utils.sname (Utils.qualifyUnionFieldName "MATCHED." sn fname)),+ Syntax.extractPatArgs = patArgs})+ applied = applyVar fterm v+ in (Eithers.bind (encodeTerm cx g applied) (\body -> Right (Syntax.Case {+ Syntax.casePat = pat,+ Syntax.caseCond = Nothing,+ Syntax.caseBody = body})))++-- | Encode a complex term definition with proper parameter types from the type signature+encodeComplexTermDef :: t0 -> Graph.Graph -> String -> Core.Term -> Core.Type -> Either Errors.Error Syntax.Stat+encodeComplexTermDef cx g lname term typ =++ let doms = extractDomains typ+ paramNames = extractParams term+ paramCount = Math.min (Lists.length paramNames) (Lists.length doms)+ cod = dropDomains paramCount typ+ zippedParams = Lists.zip (Lists.take paramCount paramNames) (Lists.take paramCount doms)+ freeTypeVars =+ Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ))+ tparams = Lists.map (\tv -> Utils.stparam tv) freeTypeVars+ letBindings = extractLetBindings term+ gWithTypeVars =+ Graph.Graph {+ Graph.graphBoundTerms = (Graph.graphBoundTerms g),+ Graph.graphBoundTypes = (Graph.graphBoundTypes g),+ Graph.graphClassConstraints = (Graph.graphClassConstraints g),+ Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),+ Graph.graphMetadata = (Graph.graphMetadata g),+ Graph.graphPrimitives = (Graph.graphPrimitives g),+ Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),+ Graph.graphTypeVariables = (Sets.union (Sets.fromList freeTypeVars) (Graph.graphTypeVariables g))}+ in (Eithers.bind (Eithers.mapList (encodeTypedParam cx gWithTypeVars) zippedParams) (\sparams -> Eithers.bind (encodeTerm cx gWithTypeVars (extractBody term)) (\sbody -> Eithers.bind (encodeType cx g cod) (\scod ->+ let gForLets =+ Logic.ifElse (Lists.null letBindings) gWithTypeVars (Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing) gWithTypeVars (Core.Let {+ Core.letBindings = letBindings,+ Core.letBody = (Core.TermVariable (Core.Name "dummy"))}))+ in (Eithers.bind (Eithers.mapList (encodeLetBinding cx gForLets (Sets.fromList freeTypeVars)) letBindings) (\sbindings ->+ let defBody =+ Logic.ifElse (Lists.null sbindings) sbody (Syntax.DataBlock (Syntax.BlockData {+ Syntax.blockDataStats = (Lists.concat2 sbindings [+ Syntax.StatTerm sbody])}))+ in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {+ Syntax.defDefnMods = [],+ Syntax.defDefnName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString lname)},+ Syntax.defDefnTparams = tparams,+ Syntax.defDefnParamss = (Lists.map (\p -> [+ p]) sparams),+ Syntax.defDefnDecltpe = (Just scod),+ Syntax.defDefnBody = defBody}))))))))))++-- | Encode a Hydra function-valued term (lambda, project, cases, or unwrap) as a Scala expression+encodeFunction :: t0 -> Graph.Graph -> M.Map Core.Name Core.Term -> Core.Term -> Maybe Core.Term -> Either Errors.Error Syntax.Data+encodeFunction cx g meta funTerm arg =+ case (Strip.deannotateAndDetypeTerm funTerm) of+ Core.TermLambda v0 ->+ let param = Core.lambdaParameter v0+ v = Utils.scalaEscapeName (Core.unName param)+ body = Core.lambdaBody v0+ rawMdom = Core.lambdaDomain v0+ mdom =+ Optionals.bind rawMdom (\dom ->+ let freeVars = Variables.freeVariablesInType dom+ unqualifiedFreeVars =+ Sets.fromList (Lists.filter (\n -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName n)))) (Sets.toList freeVars))+ unresolvedVars = Sets.difference unqualifiedFreeVars (Graph.graphTypeVariables g)+ in (Logic.ifElse (Sets.null unresolvedVars) (Just dom) Nothing))+ in (Eithers.bind (encodeTerm cx g body) (\sbody -> Eithers.bind (Optionals.cases mdom (findSdom cx g meta) (\dom -> Eithers.bind (encodeType cx g dom) (\sdom -> Right (Just sdom)))) (\sdom -> Right (Utils.slambda v sbody sdom))))+ Core.TermUnwrap _ -> Optionals.cases arg (Eithers.bind (findSdom cx g meta) (\sdom -> Right (Utils.slambda "x" (Utils.sname "x") sdom))) (\a -> encodeTerm cx g a)+ Core.TermProject v0 ->+ let fname = Utils.scalaEscapeName (Core.unName (Core.projectionFieldName v0))+ typeName = Core.projectionTypeName v0+ pv = "x"+ in (Optionals.cases arg (Eithers.bind (Eithers.either (\_ -> Right Nothing) (\msdom -> Right msdom) (findSdom cx g meta)) (\msdom -> Right (Utils.slambda pv (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {+ Syntax.selectDataQual = (Utils.sname pv),+ Syntax.selectDataName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString fname)}}))) msdom))) (\a -> Eithers.bind (encodeTerm cx g a) (\sa -> Right (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {+ Syntax.selectDataQual = sa,+ Syntax.selectDataName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString fname)}}))))))+ Core.TermCases v0 ->+ let v = "v"+ tname = Core.caseStatementTypeName v0+ dom = Core.TypeVariable tname+ sn = Utils.nameOfType g dom+ cases = Core.caseStatementCases v0+ dflt = Core.caseStatementDefault v0+ ftypes = Eithers.either (\_ -> Maps.empty) (\x_ -> x_) (Resolution.fieldTypes cx g dom)+ in (Eithers.bind (Eithers.mapList (\f -> encodeCase cx g ftypes sn f) cases) (\fieldCases -> Eithers.bind (Optionals.cases dflt (Right fieldCases) (\dfltTerm -> Eithers.bind (encodeTerm cx g dfltTerm) (\sdflt -> Right (Lists.concat2 fieldCases [+ Syntax.Case {+ Syntax.casePat = Syntax.PatWildcard,+ Syntax.caseCond = Nothing,+ Syntax.caseBody = sdflt}])))) (\scases -> Optionals.cases arg (Eithers.bind (findSdom cx g meta) (\sdom -> Right (Utils.slambda v (Syntax.DataMatch (Syntax.MatchData {+ Syntax.matchDataExpr = (Utils.sname v),+ Syntax.matchDataCases = scases})) sdom))) (\a -> Eithers.bind (encodeTerm cx g a) (\sa -> Right (Syntax.DataMatch (Syntax.MatchData {+ Syntax.matchDataExpr = sa,+ Syntax.matchDataCases = scases})))))))+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported function"))++-- | Encode a let binding as a val or def declaration. outerTypeVars are type params from the enclosing scope.+encodeLetBinding :: t0 -> Graph.Graph -> S.Set Core.Name -> Core.Binding -> Either Errors.Error Syntax.Stat+encodeLetBinding cx g outerTypeVars b =++ let bname = Utils.scalaEscapeName (Core.unName (Core.bindingName b))+ bterm = Core.bindingTerm b+ mts = Optionals.cases (Core.bindingTypeScheme b) (Maps.lookup (Core.bindingName b) (Graph.graphBoundTypes g)) (\ts -> Just ts)+ isFn =+ Optionals.cases mts False (\ts -> case (Strip.deannotateType (Core.typeSchemeBody ts)) of+ Core.TypeFunction _ -> True+ Core.TypeForall v0 -> case (Strip.deannotateType (Core.forallTypeBody v0)) of+ Core.TypeFunction _ -> True+ _ -> False+ _ -> False)+ in (Optionals.cases mts (Eithers.bind (encodeTerm cx g bterm) (\srhs -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {+ Syntax.valDefnMods = [+ Syntax.ModLazy],+ Syntax.valDefnPats = [+ Syntax.PatVar (Syntax.VarPat {+ Syntax.varPatName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString bname)}})],+ Syntax.valDefnDecltpe = Nothing,+ Syntax.valDefnRhs = srhs}))))) (\ts ->+ let newVars = Lists.filter (\v -> Logic.not (Sets.member v outerTypeVars)) (Core.typeSchemeVariables ts)+ useDef = Logic.or isFn (Logic.not (Lists.null newVars))+ in (Logic.ifElse useDef (encodeLocalDef cx g outerTypeVars bname bterm (Core.typeSchemeBody ts)) (Eithers.bind (encodeTerm cx g bterm) (\srhs -> Eithers.bind (encodeType cx g (Core.typeSchemeBody ts)) (\styp -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {+ Syntax.valDefnMods = [+ Syntax.ModLazy],+ Syntax.valDefnPats = [+ Syntax.PatVar (Syntax.VarPat {+ Syntax.varPatName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString bname)}})],+ Syntax.valDefnDecltpe = (Just styp),+ Syntax.valDefnRhs = srhs})))))))))++-- | Encode a literal value as a Scala literal+encodeLiteral :: t0 -> t1 -> Core.Literal -> Either Errors.Error Syntax.Lit+encodeLiteral cx g av =+ case av of+ Core.LiteralBinary v0 -> Right (Syntax.LitBytes (Literals.binaryToBytes v0))+ Core.LiteralBoolean v0 -> Right (Syntax.LitBoolean v0)+ Core.LiteralDecimal v0 -> Right (Syntax.LitString (Literals.showDecimal v0))+ Core.LiteralFloat v0 -> case v0 of+ Core.FloatValueFloat32 v1 -> Right (Syntax.LitFloat v1)+ Core.FloatValueFloat64 v1 -> Right (Syntax.LitDouble v1)+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected float value"))+ Core.LiteralInteger v0 -> case v0 of+ Core.IntegerValueBigint v1 -> Right (Syntax.LitLong (Literals.bigintToInt64 v1))+ Core.IntegerValueInt8 v1 -> Right (Syntax.LitByte v1)+ Core.IntegerValueInt16 v1 -> Right (Syntax.LitShort v1)+ Core.IntegerValueInt32 v1 -> Right (Syntax.LitInt v1)+ Core.IntegerValueInt64 v1 -> Right (Syntax.LitLong v1)+ Core.IntegerValueUint8 v1 -> Right (Syntax.LitByte (Literals.bigintToInt8 (Literals.uint8ToBigint v1)))+ Core.IntegerValueUint16 v1 -> Right (Syntax.LitInt (Literals.bigintToInt32 (Literals.uint16ToBigint v1)))+ Core.IntegerValueUint32 v1 -> Right (Syntax.LitLong (Literals.bigintToInt64 (Literals.uint32ToBigint v1)))+ Core.IntegerValueUint64 v1 -> Right (Syntax.LitLong (Literals.bigintToInt64 (Literals.uint64ToBigint v1)))+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected integer value"))+ Core.LiteralString v0 -> Right (Syntax.LitString v0)+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected literal"))++-- | Encode a local def. outerTypeVars are type params already in scope (don't redeclare them).+encodeLocalDef :: t0 -> Graph.Graph -> S.Set Core.Name -> String -> Core.Term -> Core.Type -> Either Errors.Error Syntax.Stat+encodeLocalDef cx g outerTypeVars lname term typ =++ let freeTypeVars =+ Lists.filter (\v -> Logic.and (Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Logic.not (Sets.member v outerTypeVars))) (Sets.toList (Variables.freeVariablesInType typ))+ doms = extractDomains typ+ paramNames = extractParams term+ paramCount = Math.min (Lists.length paramNames) (Lists.length doms)+ cod = dropDomains paramCount typ+ zippedParams = Lists.zip (Lists.take paramCount paramNames) (Lists.take paramCount doms)+ letBindings = extractLetBindings term+ tparams = Lists.map (\tv -> Utils.stparam tv) freeTypeVars+ allTypeVars = Sets.union outerTypeVars (Sets.fromList freeTypeVars)+ gWithTypeVars =+ Graph.Graph {+ Graph.graphBoundTerms = (Graph.graphBoundTerms g),+ Graph.graphBoundTypes = (Graph.graphBoundTypes g),+ Graph.graphClassConstraints = (Graph.graphClassConstraints g),+ Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),+ Graph.graphMetadata = (Graph.graphMetadata g),+ Graph.graphPrimitives = (Graph.graphPrimitives g),+ Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),+ Graph.graphTypeVariables = (Sets.union allTypeVars (Graph.graphTypeVariables g))}+ in (Eithers.bind (Eithers.mapList (encodeTypedParam cx gWithTypeVars) zippedParams) (\sparams -> Eithers.bind (encodeTerm cx gWithTypeVars (extractBody term)) (\sbody -> Eithers.bind (encodeType cx gWithTypeVars cod) (\scod ->+ let gForLets =+ Logic.ifElse (Lists.null letBindings) gWithTypeVars (Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing) gWithTypeVars (Core.Let {+ Core.letBindings = letBindings,+ Core.letBody = (Core.TermVariable (Core.Name "dummy"))}))+ in (Eithers.bind (Eithers.mapList (encodeLetBinding cx gForLets allTypeVars) letBindings) (\sbindings ->+ let defBody =+ Logic.ifElse (Lists.null sbindings) sbody (Syntax.DataBlock (Syntax.BlockData {+ Syntax.blockDataStats = (Lists.concat2 sbindings [+ Syntax.StatTerm sbody])}))+ in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {+ Syntax.defDefnMods = [],+ Syntax.defDefnName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString lname)},+ Syntax.defDefnTparams = tparams,+ Syntax.defDefnParamss = (Lists.map (\p -> [+ p]) sparams),+ Syntax.defDefnDecltpe = (Just scod),+ Syntax.defDefnBody = defBody}))))))))))++-- | Encode a Hydra term as a Scala expression+encodeTerm :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error Syntax.Data+encodeTerm cx g term0 =++ let term = stripWrapEliminations term0+ in case (Strip.deannotateTerm term) of+ Core.TermTypeApplication v0 ->+ let collectTypeArgs =+ \t -> \acc -> case (Strip.deannotateTerm t) of+ Core.TermTypeApplication v1 -> collectTypeArgs (Core.typeApplicationTermBody v1) (Lists.cons (Core.typeApplicationTermType v1) acc)+ _ -> (acc, t)+ collected = collectTypeArgs (Core.typeApplicationTermBody v0) [+ Core.typeApplicationTermType v0]+ typeArgs = Pairs.first collected+ innerTerm = Pairs.second collected+ collectTypeLambdas =+ \t -> \acc -> case (Strip.deannotateTerm t) of+ Core.TermTypeLambda v1 -> collectTypeLambdas (Core.typeLambdaBody v1) (Lists.cons (Core.typeLambdaParameter v1) acc)+ _ -> (acc, t)+ tlCollected = collectTypeLambdas innerTerm []+ typeParams = Pairs.first tlCollected+ bodyAfterTypeLambdas = Pairs.second tlCollected+ substitutedBody = bodyAfterTypeLambdas+ in case (Strip.deannotateTerm substitutedBody) of+ Core.TermProject _ -> encodeTerm cx g substitutedBody+ Core.TermCases _ -> encodeTerm cx g substitutedBody+ Core.TermUnwrap _ -> encodeTerm cx g substitutedBody+ Core.TermVariable v1 -> Eithers.bind (Eithers.mapList (\targ -> encodeType cx g targ) typeArgs) (\stypeArgs -> Optionals.cases (Maps.lookup v1 (Graph.graphPrimitives g)) (Eithers.bind (encodeTerm cx g substitutedBody) (\svar -> Right (Utils.sapplyTypes svar stypeArgs))) (\_prim -> Right (Utils.sapplyTypes (Utils.sprim v1) stypeArgs)))+ _ -> encodeTerm cx g substitutedBody+ Core.TermTypeLambda v0 -> encodeTerm cx (Scoping.extendGraphForTypeLambda g v0) (Core.typeLambdaBody v0)+ Core.TermApplication v0 ->+ let fun = Core.applicationFunction v0+ arg = Core.applicationArgument v0+ in case (Strip.deannotateAndDetypeTerm fun) of+ Core.TermLambda v1 ->+ let lamBody = Core.lambdaBody v1+ in case (Strip.deannotateAndDetypeTerm lamBody) of+ Core.TermApplication v2 ->+ let innerFun = Core.applicationFunction v2+ in case (Strip.deannotateAndDetypeTerm innerFun) of+ Core.TermCases _ -> encodeFunction cx g (Annotations.termAnnotationInternal innerFun) innerFun (Just arg)+ _ -> Eithers.bind (encodeTerm cx g fun) (\sfun -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Utils.sapply sfun [+ sarg])))+ _ -> Eithers.bind (encodeTerm cx g fun) (\sfun -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Utils.sapply sfun [+ sarg])))+ Core.TermProject v1 ->+ let fname = Utils.scalaEscapeName (Core.unName (Core.projectionFieldName v1))+ in (Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {+ Syntax.selectDataQual = sarg,+ Syntax.selectDataName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString fname)}})))))+ Core.TermCases _ -> encodeFunction cx g (Annotations.termAnnotationInternal fun) fun (Just arg)+ _ -> Eithers.bind (encodeTerm cx g fun) (\sfun -> Eithers.bind (encodeTerm cx g arg) (\sarg -> Right (Utils.sapply sfun [+ sarg])))+ Core.TermLambda _ -> encodeFunction cx g (Annotations.termAnnotationInternal term) term Nothing+ Core.TermProject _ -> encodeFunction cx g (Annotations.termAnnotationInternal term) term Nothing+ Core.TermCases _ -> encodeFunction cx g (Annotations.termAnnotationInternal term) term Nothing+ Core.TermUnwrap _ -> encodeFunction cx g (Annotations.termAnnotationInternal term) term Nothing+ Core.TermList v0 -> Eithers.bind (Eithers.mapList (\e -> encodeTerm cx g e) v0) (\sels -> Right (Utils.sapply (Utils.sname "Seq") sels))+ Core.TermLiteral v0 -> Eithers.bind (encodeLiteral cx g v0) (\slit ->+ let litData = Syntax.DataLit slit+ in case v0 of+ Core.LiteralDecimal _ -> Right (Utils.sapply (Utils.sname "BigDecimal") [+ litData])+ Core.LiteralInteger v1 -> case v1 of+ Core.IntegerValueBigint v2 -> Right (Utils.sapply (Utils.sname "BigInt") [+ Syntax.DataLit (Syntax.LitString (Literals.showBigint v2))])+ Core.IntegerValueUint64 v2 -> Right (Utils.sapply (Utils.sname "BigInt") [+ Syntax.DataLit (Syntax.LitString (Literals.showBigint (Literals.uint64ToBigint v2)))])+ _ -> Right litData+ _ -> Right litData)+ Core.TermMap v0 -> Eithers.bind (Eithers.mapList (\kv -> Eithers.bind (encodeTerm cx g (Pairs.first kv)) (\sk -> Eithers.bind (encodeTerm cx g (Pairs.second kv)) (\sv -> Right (Utils.sassign sk sv)))) (Maps.toList v0)) (\spairs -> Right (Utils.sapply (Utils.sname "Map") spairs))+ Core.TermWrap v0 -> encodeTerm cx g (Core.wrappedTermBody v0)+ Core.TermOptional v0 -> Optionals.cases v0 (Right (Utils.sname "None")) (\t -> Eithers.bind (encodeTerm cx g t) (\s -> Right (Utils.sapply (Utils.sname "Some") [+ s])))+ Core.TermRecord v0 ->+ let rname = Core.recordTypeName v0+ fields = Core.recordFields v0+ n = Utils.scalaTypeName True rname+ in (Eithers.bind (Eithers.mapList (\f -> encodeTerm cx g (Core.fieldTerm f)) fields) (\args -> Right (Utils.sapply (Utils.sname n) args)))+ Core.TermSet v0 -> Eithers.bind (Eithers.mapList (\e -> encodeTerm cx g e) (Sets.toList v0)) (\sels -> Right (Utils.sapply (Utils.sname "scala.collection.immutable.Set") sels))+ Core.TermInject v0 ->+ let sn = Core.injectionTypeName v0+ fn = Core.fieldName (Core.injectionField v0)+ ft = Core.fieldTerm (Core.injectionField v0)+ lhs = Utils.sname (Utils.qualifyUnionFieldName "UNION." (Just sn) fn)+ unionFtypes = Eithers.either (\_ -> Maps.empty) (\x_ -> x_) (Resolution.fieldTypes cx g (Core.TypeVariable sn))+ in (Logic.ifElse (Optionals.cases (Maps.lookup fn unionFtypes) (case (Strip.deannotateAndDetypeTerm ft) of+ Core.TermUnit -> True+ Core.TermRecord v1 -> Equality.equal (Lists.length (Core.recordFields v1)) 0+ _ -> False) (\dom -> case (Strip.deannotateType dom) of+ Core.TypeUnit -> True+ Core.TypeRecord v1 -> Equality.equal (Lists.length v1) 0+ _ -> False)) (Right lhs) (Eithers.bind (encodeTerm cx g ft) (\sarg -> Right (Utils.sapply lhs [+ sarg]))))+ Core.TermVariable v0 ->+ let fullName = Core.unName v0+ localName = Names.localNameOf v0+ parts = Strings.splitOn "." fullName+ numParts = Lists.length parts+ escaped =+ Logic.ifElse (Equality.lte numParts 1) (Utils.scalaEscapeName fullName) (Logic.ifElse (Equality.equal numParts 2) (Strings.cat2 (Optionals.fromOptional fullName (Lists.maybeHead parts)) (Strings.cat2 "." (Utils.scalaEscapeName localName))) (Strings.intercalate "." (Lists.concat2 (Lists.take (Math.sub numParts 1) parts) [+ Utils.scalaEscapeName localName])))+ in (Right (Utils.sname escaped))+ Core.TermAnnotated v0 -> encodeTerm cx g (Core.annotatedTermBody v0)+ Core.TermEither v0 -> Eithers.either (\l -> Eithers.bind (encodeTerm cx g l) (\sl -> Right (Utils.sapply (Utils.sname "Left") [+ sl]))) (\r -> Eithers.bind (encodeTerm cx g r) (\sr -> Right (Utils.sapply (Utils.sname "Right") [+ sr]))) v0+ Core.TermPair v0 -> Eithers.bind (encodeTerm cx g (Pairs.first v0)) (\sf -> Eithers.bind (encodeTerm cx g (Pairs.second v0)) (\ss -> Right (Utils.sapply (Utils.sname "Tuple2") [+ sf,+ ss])))+ Core.TermUnit -> Right (Syntax.DataLit Syntax.LitUnit)+ Core.TermLet v0 ->+ let bindings = Core.letBindings v0+ body = Core.letBody v0+ gLet =+ Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing) g v0+ in (Eithers.bind (Eithers.mapList (encodeLetBinding cx gLet (Graph.graphTypeVariables gLet)) bindings) (\sbindings -> Eithers.bind (encodeTerm cx gLet body) (\sbody -> Right (Syntax.DataBlock (Syntax.BlockData {+ Syntax.blockDataStats = (Lists.concat2 sbindings [+ Syntax.StatTerm sbody])})))))+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected term"))++-- | Encode a term definition as a Scala statement+encodeTermDefinition :: t0 -> Graph.Graph -> Packaging.TermDefinition -> Either Errors.Error Syntax.Stat+encodeTermDefinition cx g td =++ let name = Packaging.termDefinitionName td+ term = Packaging.termDefinitionBody td+ lname = Utils.scalaEscapeName (Names.localNameOf name)+ typ_ =+ Optionals.cases (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature td)) (Core.TypeVariable (Core.Name "hydra.core.Unit")) Core.typeSchemeBody+ isFunctionType =+ case (Strip.deannotateType typ_) of+ Core.TypeFunction _ -> True+ Core.TypeForall v0 -> case (Strip.deannotateType (Core.forallTypeBody v0)) of+ Core.TypeFunction _ -> True+ _ -> False+ _ -> False+ freeTypeVarsInTyp =+ Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ_))+ in (Logic.ifElse isFunctionType (encodeComplexTermDef cx g lname term typ_) (Logic.ifElse (Lists.null freeTypeVarsInTyp) (Eithers.bind (encodeType cx g typ_) (\stype -> Eithers.bind (encodeTerm cx g term) (\rhs -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {+ Syntax.valDefnMods = [+ Syntax.ModLazy],+ Syntax.valDefnPats = [+ Syntax.PatVar (Syntax.VarPat {+ Syntax.varPatName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString lname)}})],+ Syntax.valDefnDecltpe = (Just stype),+ Syntax.valDefnRhs = rhs})))))) (Eithers.bind (encodeType cx g typ_) (\stype -> Eithers.bind (encodeTerm cx g term) (\rhs ->+ let tparams = Lists.map (\tv -> Utils.stparam tv) freeTypeVarsInTyp+ in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {+ Syntax.defDefnMods = [],+ Syntax.defDefnName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString lname)},+ Syntax.defDefnTparams = tparams,+ Syntax.defDefnParamss = [],+ Syntax.defDefnDecltpe = (Just stype),+ Syntax.defDefnBody = rhs})))))))))++-- | Encode a Hydra type as a Scala type+encodeType :: t0 -> t1 -> Core.Type -> Either Errors.Error Syntax.Type+encodeType cx g t =+ case (Strip.deannotateType t) of+ Core.TypeApplication v0 ->+ let collectTypeArgs =+ \t2 -> \acc -> case (Strip.deannotateType t2) of+ Core.TypeApplication v1 ->+ let f2 = Core.applicationTypeFunction v1+ a2 = Core.applicationTypeArgument v1+ in (collectTypeArgs f2 (Lists.cons a2 acc))+ _ -> (t2, acc)+ collected = collectTypeArgs (Core.TypeApplication v0) []+ baseFun = Pairs.first collected+ allArgs = Pairs.second collected+ in (Eithers.bind (encodeType cx g baseFun) (\sfun -> Eithers.bind (Eithers.mapList (\a -> encodeType cx g a) allArgs) (\sargs -> Right (Utils.stapply sfun sargs))))+ Core.TypeUnit -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "Unit"})))+ Core.TypeEither v0 ->+ let lt = Core.eitherTypeLeft v0+ rt = Core.eitherTypeRight v0+ in (Eithers.bind (encodeType cx g lt) (\slt -> Eithers.bind (encodeType cx g rt) (\srt -> Right (Utils.stapply2 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "Either"}))) slt srt))))+ Core.TypeEffect v0 -> encodeType cx g v0+ Core.TypeFunction v0 ->+ let dom = Core.functionTypeDomain v0+ cod = Core.functionTypeCodomain v0+ in (Eithers.bind (encodeType cx g dom) (\sdom -> Eithers.bind (encodeType cx g cod) (\scod -> Right (Syntax.TypeFunction (Syntax.FunctionType {+ Syntax.functionTypeParams = [+ sdom],+ Syntax.functionTypeRes = scod})))))+ Core.TypeList v0 -> Eithers.bind (encodeType cx g v0) (\slt -> Right (Utils.stapply1 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.collection.immutable.Seq"}))) slt))+ Core.TypeLiteral v0 -> case v0 of+ Core.LiteralTypeBinary -> Right (Utils.stapply (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Array"}))) [+ Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Byte"}))])+ Core.LiteralTypeBoolean -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Boolean"})))+ Core.LiteralTypeDecimal -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.math.BigDecimal"})))+ Core.LiteralTypeFloat v1 -> case v1 of+ Core.FloatTypeFloat32 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Float"})))+ Core.FloatTypeFloat64 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Double"})))+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported float type"))+ Core.LiteralTypeInteger v1 -> case v1 of+ Core.IntegerTypeBigint -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.math.BigInt"})))+ Core.IntegerTypeInt8 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Byte"})))+ Core.IntegerTypeInt16 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Short"})))+ Core.IntegerTypeInt32 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Int"})))+ Core.IntegerTypeInt64 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Long"})))+ Core.IntegerTypeUint8 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Byte"})))+ Core.IntegerTypeUint16 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Int"})))+ Core.IntegerTypeUint32 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Long"})))+ Core.IntegerTypeUint64 -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.math.BigInt"})))+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported integer type"))+ Core.LiteralTypeString -> Right (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Predef.String"})))+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported literal type"))+ Core.TypeMap v0 ->+ let kt = Core.mapTypeKeys v0+ vt = Core.mapTypeValues v0+ in (Eithers.bind (encodeType cx g kt) (\skt -> Eithers.bind (encodeType cx g vt) (\svt -> Right (Utils.stapply2 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.collection.immutable.Map"}))) skt svt))))+ Core.TypeOptional v0 -> Eithers.bind (encodeType cx g v0) (\sot -> Right (Utils.stapply1 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.Option"}))) sot))+ Core.TypePair v0 ->+ let ft = Core.pairTypeFirst v0+ st = Core.pairTypeSecond v0+ in (Eithers.bind (encodeType cx g ft) (\sft -> Eithers.bind (encodeType cx g st) (\sst -> Right (Utils.stapply2 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "Tuple2"}))) sft sst))))+ Core.TypeRecord _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous record type"))+ Core.TypeSet v0 -> Eithers.bind (encodeType cx g v0) (\sst -> Right (Utils.stapply1 (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = "scala.collection.immutable.Set"}))) sst))+ Core.TypeUnion _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous union type"))+ Core.TypeWrap _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected anonymous wrap type"))+ Core.TypeForall v0 ->+ let v = Core.forallTypeParameter v0+ body = Core.forallTypeBody v0+ in (Eithers.bind (encodeType cx g body) (\sbody -> Right (Syntax.TypeLambda (Syntax.LambdaType {+ Syntax.lambdaTypeTparams = [+ Utils.stparam v],+ Syntax.lambdaTypeTpe = sbody}))))+ Core.TypeVariable v0 ->+ let rawName = Core.unName v0+ typeName = Logic.ifElse (Lists.elem 46 (Strings.toList rawName)) rawName (Formatting.capitalize rawName)+ in (Right (Syntax.TypeVar (Syntax.VarType {+ Syntax.varTypeName = Syntax.NameType {+ Syntax.nameTypeValue = typeName}})))+ _ -> Left (Errors.ErrorOther (Errors.OtherError "unsupported type"))++-- | Encode a type definition as a Scala statement+encodeTypeDefinition :: t0 -> t1 -> Packaging.TypeDefinition -> Either Errors.Error Syntax.Stat+encodeTypeDefinition cx g td =++ let name = Packaging.typeDefinitionName td+ typ = Core.typeSchemeBody (Packaging.typeDefinitionBody td)+ lname = Names.localNameOf name+ tname = Syntax.NameType {+ Syntax.nameTypeValue = lname}+ dname = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString lname)}+ freeVars =+ Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ))+ tparams =+ Lists.map (\_v ->+ let vn = Formatting.capitalize (Core.unName _v)+ in Syntax.ParamType {+ Syntax.paramTypeMods = [],+ Syntax.paramTypeName = (Syntax.NameValue vn),+ Syntax.paramTypeTparams = [],+ Syntax.paramTypeTbounds = [],+ Syntax.paramTypeVbounds = [],+ Syntax.paramTypeCbounds = []}) freeVars+ in case (Strip.deannotateType typ) of+ Core.TypeForall v0 ->+ let forallBody = Core.forallTypeBody v0+ forallParam = Core.forallTypeParameter v0+ collectForallParams =+ \t -> \acc -> case (Strip.deannotateType t) of+ Core.TypeForall v1 -> collectForallParams (Core.forallTypeBody v1) (Lists.cons (Core.forallTypeParameter v1) acc)+ _ -> (acc, t)+ collected = collectForallParams forallBody [+ forallParam]+ allForallParams = Lists.reverse (Pairs.first collected)+ innerBody = Pairs.second collected+ allTparams =+ Lists.map (\_v ->+ let vn = Formatting.capitalize (Core.unName _v)+ in Syntax.ParamType {+ Syntax.paramTypeMods = [],+ Syntax.paramTypeName = (Syntax.NameValue vn),+ Syntax.paramTypeTparams = [],+ Syntax.paramTypeTbounds = [],+ Syntax.paramTypeVbounds = [],+ Syntax.paramTypeCbounds = []}) allForallParams+ in case (Strip.deannotateType innerBody) of+ Core.TypeRecord v1 -> (\rt -> Eithers.bind (Eithers.mapList (\f -> fieldToParam cx g f) rt) (\params -> Right (Syntax.StatDefn (Syntax.DefnClass (Syntax.ClassDefn {+ Syntax.classDefnMods = [+ Syntax.ModCase],+ Syntax.classDefnName = tname,+ Syntax.classDefnTparams = allTparams,+ Syntax.classDefnCtor = Syntax.PrimaryCtor {+ Syntax.primaryCtorMods = [],+ Syntax.primaryCtorName = (Syntax.NameValue ""),+ Syntax.primaryCtorParamss = [+ params]},+ Syntax.classDefnTemplate = Syntax.Template {+ Syntax.templateEarly = [],+ Syntax.templateInits = [],+ Syntax.templateSelf = (Syntax.Self ()),+ Syntax.templateStats = []}}))))) v1+ Core.TypeUnion v1 -> (\g2 -> \rt -> Eithers.bind (Eithers.mapList (\f -> fieldToEnumCase cx g2 lname allTparams f) rt) (\cases -> Right (Syntax.StatDefn (Syntax.DefnEnum (Syntax.EnumDefn {+ Syntax.enumDefnMods = [],+ Syntax.enumDefnName = tname,+ Syntax.enumDefnTparams = allTparams,+ Syntax.enumDefnCtor = Syntax.PrimaryCtor {+ Syntax.primaryCtorMods = [],+ Syntax.primaryCtorName = (Syntax.NameValue ""),+ Syntax.primaryCtorParamss = []},+ Syntax.enumDefnTemplate = Syntax.Template {+ Syntax.templateEarly = [],+ Syntax.templateInits = [],+ Syntax.templateSelf = (Syntax.Self ()),+ Syntax.templateStats = cases}}))))) g v1+ Core.TypeWrap v1 -> Eithers.bind (encodeType cx g v1) (\styp -> Right (Syntax.StatDefn (Syntax.DefnType (Syntax.TypeDefn {+ Syntax.typeDefnMods = [],+ Syntax.typeDefnName = tname,+ Syntax.typeDefnTparams = allTparams,+ Syntax.typeDefnBody = styp}))))+ _ -> (\cx2 -> \g2 -> \typ2 ->+ let mkAlias =+ \styp -> Right (Syntax.StatDefn (Syntax.DefnType (Syntax.TypeDefn {+ Syntax.typeDefnMods = [],+ Syntax.typeDefnName = Syntax.NameType {+ Syntax.nameTypeValue = lname},+ Syntax.typeDefnTparams = allTparams,+ Syntax.typeDefnBody = styp})))+ in (Eithers.either (\_ -> mkAlias (Utils.stref "Any")) mkAlias (encodeType cx2 g2 typ2))) cx g innerBody+ Core.TypeRecord v0 -> (\cx2 -> \g2 -> \rt2 -> Eithers.bind (Eithers.mapList (\f -> fieldToParam cx2 g2 f) rt2) (\params -> Right (Syntax.StatDefn (Syntax.DefnClass (Syntax.ClassDefn {+ Syntax.classDefnMods = [+ Syntax.ModCase],+ Syntax.classDefnName = tname,+ Syntax.classDefnTparams = tparams,+ Syntax.classDefnCtor = Syntax.PrimaryCtor {+ Syntax.primaryCtorMods = [],+ Syntax.primaryCtorName = (Syntax.NameValue ""),+ Syntax.primaryCtorParamss = [+ params]},+ Syntax.classDefnTemplate = Syntax.Template {+ Syntax.templateEarly = [],+ Syntax.templateInits = [],+ Syntax.templateSelf = (Syntax.Self ()),+ Syntax.templateStats = []}}))))) cx g v0+ Core.TypeUnion v0 -> (\tparams2 -> \cx2 -> \g2 -> \rt2 -> Eithers.bind (Eithers.mapList (\f -> fieldToEnumCase cx2 g2 lname tparams2 f) rt2) (\cases -> Right (Syntax.StatDefn (Syntax.DefnEnum (Syntax.EnumDefn {+ Syntax.enumDefnMods = [],+ Syntax.enumDefnName = tname,+ Syntax.enumDefnTparams = tparams2,+ Syntax.enumDefnCtor = Syntax.PrimaryCtor {+ Syntax.primaryCtorMods = [],+ Syntax.primaryCtorName = (Syntax.NameValue ""),+ Syntax.primaryCtorParamss = []},+ Syntax.enumDefnTemplate = Syntax.Template {+ Syntax.templateEarly = [],+ Syntax.templateInits = [],+ Syntax.templateSelf = (Syntax.Self ()),+ Syntax.templateStats = cases}}))))) tparams cx g v0+ Core.TypeWrap v0 -> Eithers.bind (encodeType cx g v0) (\styp -> Right (Syntax.StatDefn (Syntax.DefnType (Syntax.TypeDefn {+ Syntax.typeDefnMods = [],+ Syntax.typeDefnName = tname,+ Syntax.typeDefnTparams = tparams,+ Syntax.typeDefnBody = styp}))))+ _ -> (\lname2 -> \tparams2 -> \cx2 -> \g2 -> \typ2 ->+ let mkAlias =+ \styp -> Right (Syntax.StatDefn (Syntax.DefnType (Syntax.TypeDefn {+ Syntax.typeDefnMods = [],+ Syntax.typeDefnName = Syntax.NameType {+ Syntax.nameTypeValue = lname2},+ Syntax.typeDefnTparams = tparams2,+ Syntax.typeDefnBody = styp})))+ in (Eithers.either (\_ -> mkAlias (Utils.stref "Any")) mkAlias (encodeType cx2 g2 typ2))) lname tparams cx g typ++-- | Encode a parameter with its type annotation+encodeTypedParam :: t0 -> t1 -> (Core.Name, Core.Type) -> Either Errors.Error Syntax.ParamData+encodeTypedParam cx g pair =++ let pname = Utils.scalaEscapeName (Names.localNameOf (Pairs.first pair))+ pdom = Pairs.second pair+ in (Eithers.bind (encodeType cx g pdom) (\sdom -> Right (Syntax.ParamData {+ Syntax.paramDataMods = [],+ Syntax.paramDataName = (Syntax.NameValue pname),+ Syntax.paramDataDecltpe = (Just sdom),+ Syntax.paramDataDefault = Nothing})))++-- | Encode an untyped application term by first inferring types+encodeUntypeApplicationTerm :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error Syntax.Data+encodeUntypeApplicationTerm cx g term =+ Eithers.bind (Inference.inferInGraphContext cx g term) (\result -> encodeTerm cx g (Typing.inferenceResultTerm result))++-- | Extract the innermost body from a term+extractBody :: Core.Term -> Core.Term+extractBody t =+ case (Strip.deannotateAndDetypeTerm t) of+ Core.TermLambda v0 -> extractBody (Core.lambdaBody v0)+ Core.TermTypeLambda v0 -> extractBody (Core.typeLambdaBody v0)+ Core.TermTypeApplication v0 -> extractBody (Core.typeApplicationTermBody v0)+ Core.TermLet v0 -> extractBody (Core.letBody v0)+ _ -> t++-- | Extract the final return type from a function type+extractCodomain :: Core.Type -> Core.Type+extractCodomain t =+ case (Strip.deannotateType t) of+ Core.TypeFunction v0 -> extractCodomain (Core.functionTypeCodomain v0)+ Core.TypeForall v0 -> extractCodomain (Core.forallTypeBody v0)+ _ -> t++-- | Extract domain types from a function type+extractDomains :: Core.Type -> [Core.Type]+extractDomains t =+ case (Strip.deannotateType t) of+ Core.TypeFunction v0 -> Lists.cons (Core.functionTypeDomain v0) (extractDomains (Core.functionTypeCodomain v0))+ Core.TypeForall v0 -> extractDomains (Core.forallTypeBody v0)+ _ -> []++-- | Extract let bindings from a term+extractLetBindings :: Core.Term -> [Core.Binding]+extractLetBindings t =+ case (Strip.deannotateAndDetypeTerm t) of+ Core.TermLambda v0 -> extractLetBindings (Core.lambdaBody v0)+ Core.TermTypeLambda v0 -> extractLetBindings (Core.typeLambdaBody v0)+ Core.TermTypeApplication v0 -> extractLetBindings (Core.typeApplicationTermBody v0)+ Core.TermLet v0 -> Lists.concat2 (Core.letBindings v0) (extractLetBindings (Core.letBody v0))+ _ -> []++-- | Extract parameter names from a term+extractParams :: Core.Term -> [Core.Name]+extractParams t =+ case (Strip.deannotateAndDetypeTerm t) of+ Core.TermLambda v0 -> Lists.cons (Core.lambdaParameter v0) (extractParams (Core.lambdaBody v0))+ Core.TermTypeLambda v0 -> extractParams (Core.typeLambdaBody v0)+ Core.TermTypeApplication v0 -> extractParams (Core.typeApplicationTermBody v0)+ Core.TermLet v0 -> extractParams (Core.letBody v0)+ _ -> []++-- | Convert a field type to a Scala enum case+fieldToEnumCase :: t0 -> t1 -> String -> [Syntax.ParamType] -> Core.FieldType -> Either Errors.Error Syntax.Stat+fieldToEnumCase cx g parentName tparams ft =++ let fname = Utils.scalaEscapeEnumCaseName (Core.unName (Core.fieldTypeName ft))+ ftyp = Core.fieldTypeType ft+ caseName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString fname)}+ isUnit =+ case (Strip.deannotateType ftyp) of+ Core.TypeUnit -> True+ Core.TypeRecord v0 -> Equality.equal (Lists.length v0) 0+ _ -> False+ parentType =+ Logic.ifElse (Lists.null tparams) (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = parentName}))) (Syntax.TypeApply (Syntax.ApplyType {+ Syntax.applyTypeTpe = (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = parentName}))),+ Syntax.applyTypeArgs = (Lists.map typeParamToTypeVar tparams)}))+ in (Eithers.bind (encodeType cx g ftyp) (\sftyp -> Right (Syntax.StatDefn (Syntax.DefnEnumCase (Syntax.EnumCaseDefn {+ Syntax.enumCaseDefnMods = [],+ Syntax.enumCaseDefnName = caseName,+ Syntax.enumCaseDefnTparams = [],+ Syntax.enumCaseDefnCtor = Syntax.PrimaryCtor {+ Syntax.primaryCtorMods = [],+ Syntax.primaryCtorName = (Syntax.NameValue ""),+ Syntax.primaryCtorParamss = [+ Logic.ifElse isUnit [] [+ Syntax.ParamData {+ Syntax.paramDataMods = [],+ Syntax.paramDataName = (Syntax.NameValue "value"),+ Syntax.paramDataDecltpe = (Just sftyp),+ Syntax.paramDataDefault = Nothing}]]},+ Syntax.enumCaseDefnInits = [+ Syntax.Init {+ Syntax.initTpe = parentType,+ Syntax.initName = (Syntax.NameValue ""),+ Syntax.initArgss = []}]})))))++-- | Convert a field type to a Scala parameter+fieldToParam :: t0 -> t1 -> Core.FieldType -> Either Errors.Error Syntax.ParamData+fieldToParam cx g ft =++ let fname = Utils.scalaEscapeName (Core.unName (Core.fieldTypeName ft))+ ftyp = Core.fieldTypeType ft+ in (Eithers.bind (encodeType cx g ftyp) (\sftyp -> Right (Syntax.ParamData {+ Syntax.paramDataMods = [],+ Syntax.paramDataName = (Syntax.NameValue fname),+ Syntax.paramDataDecltpe = (Just sftyp),+ Syntax.paramDataDefault = Nothing})))++-- | Find the domain type from annotations+findDomain :: t0 -> Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.Error Core.Type+findDomain cx g meta =+ Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g meta)) (\r -> Optionals.cases r (Left (Errors.ErrorOther (Errors.OtherError "expected a typed term"))) (\t -> case (Strip.deannotateType t) of+ Core.TypeFunction v0 -> Right (Core.functionTypeDomain v0)+ _ -> Left (Errors.ErrorOther (Errors.OtherError "expected a function type"))))++-- | Find import statements for the module+findImports :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error [Syntax.Stat]+findImports cx g mod =+ Eithers.bind (Analysis.moduleDependencyModuleNames cx g False False True False mod) (\elImps -> Eithers.bind (Analysis.moduleDependencyModuleNames cx g False True False False mod) (\primImps -> Right (Lists.concat [+ Lists.map toElImport (Sets.toList elImps),+ (Lists.map toPrimImport (Sets.toList primImps))])))++-- | Find the Scala domain type for a function from annotations+findSdom :: t0 -> Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.Error (Maybe Syntax.Type)+findSdom cx g meta =+ Eithers.bind (Eithers.bimap (\_de -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _de))) (\_a -> _a) (Annotations.getType g meta)) (\mtyp -> Optionals.cases mtyp (Right Nothing) (\t -> case (Strip.deannotateType t) of+ Core.TypeFunction v0 ->+ let dom = Core.functionTypeDomain v0+ in (Eithers.bind (encodeType cx g dom) (\sdom -> Right (Just sdom)))+ Core.TypeForall v0 -> case (Strip.deannotateType (Core.forallTypeBody v0)) of+ Core.TypeFunction v1 ->+ let dom2 = Core.functionTypeDomain v1+ in (Eithers.bind (encodeType cx g dom2) (\sdom2 -> Right (Just sdom2)))+ _ -> Right Nothing+ _ -> Eithers.bind (encodeType cx g t) (\st -> Right (Just st))))++-- | Convert a Hydra module to Scala source code+moduleToScala :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error (M.Map String String)+moduleToScala mod defs cx g =+ Eithers.bind (constructModule cx g mod defs) (\pkg ->+ let s = Serialization.printExpr (Serialization.parenthesize (Serde.pkgToExpr pkg))+ in (Right (Maps.singleton (Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "scala") (Packaging.moduleName mod)) s)))++-- | Strip wrap eliminations from terms (newtypes are erased in Scala)+stripWrapEliminations :: Core.Term -> Core.Term+stripWrapEliminations t =+ case (Strip.deannotateAndDetypeTerm t) of+ Core.TermApplication v0 ->+ let appFun = Core.applicationFunction v0+ appArg = Core.applicationArgument v0+ in case (Strip.deannotateAndDetypeTerm appFun) of+ Core.TermUnwrap _ -> stripWrapEliminations appArg+ Core.TermApplication v1 ->+ let innerFun = Core.applicationFunction v1+ innerArg = Core.applicationArgument v1+ in case (Strip.deannotateAndDetypeTerm innerFun) of+ Core.TermUnwrap _ -> stripWrapEliminations (Core.TermApplication (Core.Application {+ Core.applicationFunction = innerArg,+ Core.applicationArgument = appArg}))+ _ -> t+ _ -> t+ _ -> t++-- | Create an element import statement+toElImport :: Packaging.ModuleName -> Syntax.Stat+toElImport ns =+ Syntax.StatImportExport (Syntax.ImportExportStatImport (Syntax.Import {+ Syntax.importImporters = [+ Syntax.Importer {+ Syntax.importerRef = (Syntax.RefDataName (Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." (Packaging.unModuleName ns))))})),+ Syntax.importerImportees = [+ Syntax.ImporteeWildcard]}]}))++-- | Create a primitive import statement+toPrimImport :: Packaging.ModuleName -> Syntax.Stat+toPrimImport ns =+ Syntax.StatImportExport (Syntax.ImportExportStatImport (Syntax.Import {+ Syntax.importImporters = [+ Syntax.Importer {+ Syntax.importerRef = (Syntax.RefDataName (Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." (Packaging.unModuleName ns))))})),+ Syntax.importerImportees = []}]}))++-- | Convert a type parameter to a type variable reference+typeParamToTypeVar :: Syntax.ParamType -> Syntax.Type+typeParamToTypeVar tp =++ let n = Syntax.paramTypeName tp+ s =+ case n of+ Syntax.NameValue v0 -> v0+ _ -> ""+ in (Syntax.TypeVar (Syntax.VarType {+ Syntax.varTypeName = Syntax.NameType {+ Syntax.nameTypeValue = s}}))
+ src/main/haskell/Hydra/Scala/Language.hs view
@@ -0,0 +1,226 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Language constraints and reserved words for Scala++module Hydra.Scala.Language where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.File as ErrorFile+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Error.System as ErrorSystem+import qualified Hydra.Errors as Errors+import qualified Hydra.File as File+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.System as System+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Time as Time+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S++-- | Language constraints for Scala+scalaLanguage :: Coders.Language+scalaLanguage =+ Coders.Language {+ Coders.languageName = (Coders.LanguageName "hydra.scala"),+ Coders.languageConstraints = Coders.LanguageConstraints {+ Coders.languageConstraintsLiteralVariants = literalVariants,+ Coders.languageConstraintsFloatTypes = floatTypes,+ Coders.languageConstraintsIntegerTypes = integerTypes,+ Coders.languageConstraintsTermVariants = termVariants,+ Coders.languageConstraintsTypeVariants = typeVariants,+ Coders.languageConstraintsTypes = typePredicate},+ Coders.languageSupportedFeatures = (Sets.fromList [+ Coders.LanguageFeatureNestedCaseStatements,+ Coders.LanguageFeatureNestedPolymorphicLetBindings]),+ Coders.languageCaseConventions = Coders.CaseConventions {+ Coders.caseConventionsConstant = Util.CaseConventionUpperSnake,+ Coders.caseConventionsDirectory = Util.CaseConventionCamel,+ Coders.caseConventionsEnumValue = Util.CaseConventionPascal,+ Coders.caseConventionsField = Util.CaseConventionCamel,+ Coders.caseConventionsFile = Util.CaseConventionCamel,+ Coders.caseConventionsModule = Util.CaseConventionCamel,+ Coders.caseConventionsTerm = Util.CaseConventionCamel,+ Coders.caseConventionsTermVariable = Util.CaseConventionCamel,+ Coders.caseConventionsType = Util.CaseConventionPascal,+ Coders.caseConventionsTypeVariable = Util.CaseConventionPascal},+ Coders.languageDefaultFileExtension = (File.FileExtension "scala")}+ where+ literalVariants =+ Sets.fromList [+ Variants.LiteralVariantBoolean,+ Variants.LiteralVariantDecimal,+ Variants.LiteralVariantFloat,+ Variants.LiteralVariantInteger,+ Variants.LiteralVariantString]+ floatTypes =+ Sets.fromList [+ Core.FloatTypeFloat32,+ Core.FloatTypeFloat64]+ integerTypes =+ Sets.fromList [+ Core.IntegerTypeBigint,+ Core.IntegerTypeInt8,+ Core.IntegerTypeInt16,+ Core.IntegerTypeInt32,+ Core.IntegerTypeInt64,+ Core.IntegerTypeUint8,+ Core.IntegerTypeUint16,+ Core.IntegerTypeUint32,+ Core.IntegerTypeUint64]+ termVariants =+ Sets.fromList [+ Variants.TermVariantApplication,+ Variants.TermVariantEither,+ Variants.TermVariantCases,+ Variants.TermVariantLambda,+ Variants.TermVariantProject,+ Variants.TermVariantUnwrap,+ Variants.TermVariantTypeApplication,+ Variants.TermVariantTypeLambda,+ Variants.TermVariantLet,+ Variants.TermVariantList,+ Variants.TermVariantLiteral,+ Variants.TermVariantMap,+ Variants.TermVariantOptional,+ Variants.TermVariantPair,+ Variants.TermVariantRecord,+ Variants.TermVariantSet,+ Variants.TermVariantInject,+ Variants.TermVariantUnit,+ Variants.TermVariantVariable,+ Variants.TermVariantWrap]+ typeVariants =+ Sets.fromList [+ Variants.TypeVariantAnnotated,+ Variants.TypeVariantApplication,+ Variants.TypeVariantEither,+ Variants.TypeVariantEffect,+ Variants.TypeVariantFunction,+ Variants.TypeVariantList,+ Variants.TypeVariantLiteral,+ Variants.TypeVariantMap,+ Variants.TypeVariantOptional,+ Variants.TypeVariantPair,+ Variants.TypeVariantRecord,+ Variants.TypeVariantSet,+ Variants.TypeVariantUnion,+ Variants.TypeVariantUnit,+ Variants.TypeVariantForall,+ Variants.TypeVariantVariable,+ Variants.TypeVariantVoid,+ Variants.TypeVariantWrap]+ typePredicate = \_ -> True++-- | A set of reserved words in Scala+scalaReservedWords :: S.Set String+scalaReservedWords =+ Sets.fromList (Lists.concat [+ keywords,+ classNames])+ where+ keywords =+ [+ "abstract",+ "case",+ "catch",+ "class",+ "def",+ "do",+ "else",+ "end",+ "enum",+ "export",+ "extends",+ "false",+ "final",+ "finally",+ "for",+ "forSome",+ "given",+ "if",+ "implicit",+ "import",+ "lazy",+ "macro",+ "match",+ "new",+ "null",+ "object",+ "override",+ "package",+ "private",+ "protected",+ "return",+ "sealed",+ "super",+ "then",+ "this",+ "throw",+ "trait",+ "true",+ "try",+ "type",+ "val",+ "var",+ "while",+ "with",+ "yield"]+ classNames =+ [+ "Any",+ "AnyVal",+ "App",+ "Array",+ "Boolean",+ "Byte",+ "Char",+ "Console",+ "DelayedInit",+ "Double",+ "DummyExplicit",+ "Dynamic",+ "Enumeration",+ "Equals",+ "Float",+ "Function",+ "Int",+ "Long",+ "MatchError",+ "None",+ "Nothing",+ "Null",+ "Option",+ "PartialFunction",+ "Predef",+ "Product",+ "Proxy",+ "SerialVersionUID",+ "Short",+ "Singleton",+ "Some",+ "Specializable",+ "StringContext",+ "Symbol",+ "Unit",+ "ValueOf"]
+ src/main/haskell/Hydra/Scala/Serde.hs view
@@ -0,0 +1,435 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Serialization functions for converting Scala AST to abstract expressions++module Hydra.Scala.Serde where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.File as ErrorFile+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Error.System as ErrorSystem+import qualified Hydra.Errors as Errors+import qualified Hydra.File as File+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Jvm.Serde as Serde+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Overlay.Haskell.Lib.Math as Math+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scala.Syntax as Syntax+import qualified Hydra.Serialization as Serialization+import qualified Hydra.System as System+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Time as Time+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++-- | Convert a case clause to an expression+caseToExpr :: Syntax.Case -> Ast.Expr+caseToExpr c =++ let pat = Syntax.casePat c+ term = Syntax.caseBody c+ in (Serialization.spaceSep [+ Serialization.cst "case",+ (patToExpr pat),+ (Serialization.cst "=>"),+ (termToExpr term)])++-- | Convert a function-data lambda to an expression+dataFunctionToExpr :: Syntax.FunctionData -> Ast.Expr+dataFunctionToExpr f =++ let params = Syntax.functionDataParams f+ body = Syntax.functionDataBody f+ bodyExpr = termToExpr body+ bodyLen = Serialization.expressionLength bodyExpr+ in (Logic.ifElse (Equality.gt bodyLen 60) (Serialization.noSep [+ Serialization.parenListAdaptive (Lists.map dataParamToExpr params),+ (Serialization.cst " =>\n "),+ bodyExpr]) (Serialization.spaceSep [+ Serialization.parenListAdaptive (Lists.map dataParamToExpr params),+ (Serialization.cst "=>"),+ bodyExpr]))++-- | Convert a data name to an expression+dataNameToExpr :: Syntax.NameData -> Ast.Expr+dataNameToExpr dn = Serialization.cst (Syntax.unPredefString (Syntax.nameDataValue dn))++-- | Convert a data parameter to an expression+dataParamToExpr :: Syntax.ParamData -> Ast.Expr+dataParamToExpr dp =++ let name = Syntax.paramDataName dp+ stype = Syntax.paramDataDecltpe dp+ in (Serialization.noSep (Optionals.cat [+ Optionals.pure (nameToExpr name),+ (Optionals.map (\t -> Serialization.spaceSep [+ Serialization.cst ":",+ (typeToExpr t)]) stype)]))++-- | Convert a data reference to an expression+dataRefToExpr :: Syntax.RefData -> Ast.Expr+dataRefToExpr ref =+ case ref of+ Syntax.RefDataName v0 -> dataNameToExpr v0+ Syntax.RefDataSelect v0 -> dataSelectToExpr v0++-- | Convert a data select to an expression+dataSelectToExpr :: Syntax.SelectData -> Ast.Expr+dataSelectToExpr sel =++ let arg = Syntax.selectDataQual sel+ name = Syntax.selectDataName sel+ in (Serialization.ifx dotOp (termToExpr arg) (termToExpr (Syntax.DataRef (Syntax.RefDataName name))))++-- | Convert a definition to an expression+defnToExpr :: Syntax.Defn -> Ast.Expr+defnToExpr def =+ case def of+ Syntax.DefnDef v0 ->+ let name = Syntax.defDefnName v0+ tparams = Syntax.defDefnTparams v0+ paramss = Syntax.defDefnParamss v0+ scod = Syntax.defDefnDecltpe v0+ body = Syntax.defDefnBody v0+ tparamsExpr =+ Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams)))+ scodExpr =+ Optionals.map (\t -> Serialization.spaceSep [+ Serialization.cst ":",+ (typeToExpr t)]) scod+ paramssExprs = Lists.map (\ps -> Serialization.parenListAdaptive (Lists.map dataParamToExpr ps)) paramss+ nameAndParams =+ Serialization.noSep (Optionals.cat (Lists.concat [+ [+ Optionals.pure (dataNameToExpr name)],+ [+ tparamsExpr],+ (Lists.map (\pe -> Optionals.pure pe) paramssExprs),+ [+ scodExpr]]))+ bodyExpr = termToExpr body+ defSig =+ Serialization.spaceSep [+ Serialization.cst "def",+ nameAndParams,+ (Serialization.cst "=")]+ bodyLen = Serialization.expressionLength bodyExpr+ in (Logic.ifElse (Equality.gt bodyLen 80) (Serialization.noSep [+ defSig,+ (Serialization.cst "\n "),+ bodyExpr]) (Serialization.spaceSep [+ defSig,+ bodyExpr]))+ Syntax.DefnType v0 ->+ let name = Syntax.typeDefnName v0+ tparams = Syntax.typeDefnTparams v0+ body = Syntax.typeDefnBody v0+ in (Serialization.spaceSep (Optionals.cat [+ Optionals.pure (Serialization.cst "type"),+ (Optionals.pure (typeNameToExpr name)),+ (Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams)))),+ (Optionals.pure (Serialization.cst "=")),+ (Optionals.pure (typeToExpr body))]))+ Syntax.DefnVal v0 ->+ let mods = Syntax.valDefnMods v0+ pats = Syntax.valDefnPats v0+ typ = Syntax.valDefnDecltpe v0+ rhs = Syntax.valDefnRhs v0+ nameStr =+ Optionals.fromOptional "" (Optionals.map (\firstPat ->+ let patName =+ case firstPat of+ Syntax.PatVar v1 -> Syntax.varPatName v1+ in (Syntax.unPredefString (Syntax.nameDataValue patName))) (Lists.maybeHead pats))+ nameAndType =+ Optionals.cases typ (Serialization.cst nameStr) (\t -> Serialization.spaceSep [+ Serialization.cst (Strings.cat2 nameStr ":"),+ (typeToExpr t)])+ valKeyword = Logic.ifElse (Lists.null mods) "val" "lazy val"+ in (Serialization.spaceSep [+ Serialization.cst valKeyword,+ nameAndType,+ (Serialization.cst "="),+ (termToExpr rhs)])+ Syntax.DefnClass v0 ->+ let mods = Syntax.classDefnMods v0+ name = Syntax.classDefnName v0+ tparams = Syntax.classDefnTparams v0+ ctor = Syntax.classDefnCtor v0+ paramss = Syntax.primaryCtorParamss ctor+ tparamsExpr =+ Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams)))+ paramsExpr =+ Logic.ifElse (Lists.null paramss) Nothing (Optionals.pure (Serialization.parenListAdaptive (Lists.map dataParamToExpr (Lists.concat paramss))))+ nameAndParams =+ Serialization.noSep (Optionals.cat [+ Optionals.pure (typeNameToExpr name),+ tparamsExpr,+ paramsExpr])+ in (Serialization.spaceSep (Lists.concat [+ Lists.map modToExpr mods,+ [+ Serialization.cst "class",+ nameAndParams]]))+ Syntax.DefnEnum v0 ->+ let name = Syntax.enumDefnName v0+ tparams = Syntax.enumDefnTparams v0+ template = Syntax.enumDefnTemplate v0+ stats = Syntax.templateStats template+ enumHeader =+ Serialization.spaceSep [+ Serialization.cst "enum",+ (Serialization.noSep (Optionals.cat [+ Optionals.pure (typeNameToExpr name),+ (Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams))))])),+ (Serialization.cst ":")]+ enumCases =+ Lists.map (\s -> Serialization.spaceSep [+ Serialization.cst " ",+ (statToExpr s)]) stats+ in (Serialization.newlineSep (Lists.concat [+ [+ enumHeader],+ enumCases]))+ Syntax.DefnEnumCase v0 ->+ let name = Syntax.enumCaseDefnName v0+ ctor = Syntax.enumCaseDefnCtor v0+ inits = Syntax.enumCaseDefnInits v0+ paramss = Syntax.primaryCtorParamss ctor+ allParams = Lists.concat paramss+ params =+ Logic.ifElse (Lists.null allParams) (Serialization.cst "") (Serialization.parenListAdaptive (Lists.map dataParamToExpr allParams))+ extendsClause =+ Logic.ifElse (Lists.null inits) (Serialization.cst "") (Serialization.spaceSep [+ Serialization.cst "extends",+ (Serialization.commaSep Serialization.inlineStyle (Lists.map initToExpr inits))])+ in (Serialization.spaceSep [+ Serialization.cst "case",+ (Serialization.noSep [+ dataNameToExpr name,+ params]),+ extendsClause])++-- | The dot operator for member access+dotOp :: Ast.Op+dotOp =+ Ast.Op {+ Ast.opSymbol = (Ast.Symbol "."),+ Ast.opPadding = Ast.Padding {+ Ast.paddingLeft = Ast.WsNone,+ Ast.paddingRight = Ast.WsNone},+ Ast.opPrecedence = (Ast.Precedence 0),+ Ast.opAssociativity = Ast.AssociativityLeft}++-- | The function arrow operator (=>)+functionArrowOp :: Ast.Op+functionArrowOp = Serialization.op "=>" (Math.negate 1) Ast.AssociativityRight++-- | Convert an import/export statement to an expression+importExportStatToExpr :: Syntax.ImportExportStat -> Ast.Expr+importExportStatToExpr ie =+ case ie of+ Syntax.ImportExportStatImport v0 ->+ let importers = Syntax.importImporters v0+ in (Serialization.newlineSep (Lists.map importerToExpr importers))++-- | Convert an importer to an expression+importerToExpr :: Syntax.Importer -> Ast.Expr+importerToExpr imp =++ let ref = Syntax.importerRef imp+ importees = Syntax.importerImportees imp+ refName =+ case ref of+ Syntax.RefDataName v0 -> Syntax.unPredefString (Syntax.nameDataValue v0)+ forImportees =+ Logic.ifElse (Lists.null importees) (Serialization.cst "") (Logic.ifElse (Equality.equal (Lists.length importees) 1) (Optionals.fromOptional (Serialization.cst "") (Optionals.map (\firstImp -> Serialization.noSep [+ Serialization.cst ".",+ case firstImp of+ Syntax.ImporteeWildcard -> Serialization.cst "*"+ Syntax.ImporteeName v0 -> Serialization.cst (case (Syntax.nameImporteeName v0) of+ Syntax.NameValue v1 -> v1)]) (Lists.maybeHead importees))) (Serialization.noSep [+ Serialization.cst ".",+ (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map (\it -> case it of+ Syntax.ImporteeWildcard -> Serialization.cst "*"+ Syntax.ImporteeName v0 -> Serialization.cst (case (Syntax.nameImporteeName v0) of+ Syntax.NameValue v1 -> v1)) importees))]))+ in (Serialization.spaceSep [+ Serialization.cst "import",+ (Serialization.noSep [+ Serialization.cst refName,+ forImportees])])++-- | Convert an init to an expression+initToExpr :: Syntax.Init -> Ast.Expr+initToExpr init = typeToExpr (Syntax.initTpe init)++-- | Convert a literal to an expression+litToExpr :: Syntax.Lit -> Ast.Expr+litToExpr lit =+ case lit of+ Syntax.LitBoolean v0 -> Serialization.cst (Logic.ifElse v0 "true" "false")+ Syntax.LitByte v0 -> Serialization.cst (Strings.cat2 (Literals.showInt8 v0) ".toByte")+ Syntax.LitShort v0 -> Serialization.cst (Strings.cat2 (Literals.showInt16 v0) ".toShort")+ Syntax.LitInt v0 -> Serialization.cst (Literals.showInt32 v0)+ Syntax.LitLong v0 -> Serialization.cst (Strings.cat2 (Literals.showInt64 v0) "L")+ Syntax.LitFloat v0 -> Serialization.cst (scalaFloatLiteralText "Float" "f" (Literals.showFloat32 v0))+ Syntax.LitDouble v0 -> Serialization.cst (scalaFloatLiteralText "Double" "" (Literals.showFloat64 v0))+ Syntax.LitUnit -> Serialization.cst "()"+ Syntax.LitString v0 -> Serialization.cst (Strings.cat2 "\"" (Strings.cat2 (Serde.escapeJavaString v0) "\""))+ Syntax.LitBytes v0 -> Serialization.cst (Strings.cat2 "Array[Byte](" (Strings.cat2 (Strings.intercalate ", " (Lists.map (\b -> Strings.cat2 (Literals.showInt32 b) ".toByte") v0)) ")"))+ _ -> Serialization.cst "TODO:literal"++-- | The match operator+matchOp :: Ast.Op+matchOp =+ Ast.Op {+ Ast.opSymbol = (Ast.Symbol "match"),+ Ast.opPadding = Ast.Padding {+ Ast.paddingLeft = Ast.WsSpace,+ Ast.paddingRight = (Ast.WsBreakAndIndent " ")},+ Ast.opPrecedence = (Ast.Precedence 0),+ Ast.opAssociativity = Ast.AssociativityNone}++-- | Convert a modifier to an expression+modToExpr :: Syntax.Mod -> Ast.Expr+modToExpr m =+ case m of+ Syntax.ModCase -> Serialization.cst "case"+ Syntax.ModSealed -> Serialization.cst "sealed"+ Syntax.ModAbstract -> Serialization.cst "abstract"+ Syntax.ModFinal -> Serialization.cst "final"+ Syntax.ModOverride -> Serialization.cst "override"+ Syntax.ModImplicit -> Serialization.cst "implicit"+ Syntax.ModLazy -> Serialization.cst "lazy"+ Syntax.ModPrivate _ -> Serialization.cst "private"+ Syntax.ModProtected _ -> Serialization.cst "protected"++-- | Convert a name to an expression+nameToExpr :: Syntax.Name -> Ast.Expr+nameToExpr name =+ case name of+ Syntax.NameValue v0 -> Serialization.cst v0++-- | Convert a pattern to an expression+patToExpr :: Syntax.Pat -> Ast.Expr+patToExpr pat =+ case pat of+ Syntax.PatExtract v0 ->+ let fun = Syntax.extractPatFun v0+ args = Syntax.extractPatArgs v0+ in (Logic.ifElse (Lists.null args) (termToExpr fun) (Serialization.noSep [+ termToExpr fun,+ (Serialization.parenListAdaptive (Lists.map patToExpr args))]))+ Syntax.PatVar v0 -> dataNameToExpr (Syntax.varPatName v0)+ Syntax.PatWildcard -> Serialization.cst "_"++-- | Convert a package to an expression+pkgToExpr :: Syntax.Pkg -> Ast.Expr+pkgToExpr pkg =++ let name = Syntax.pkgName pkg+ stats = Syntax.pkgStats pkg+ package =+ Serialization.spaceSep [+ Serialization.cst "package",+ (dataNameToExpr name)]+ in (Serialization.doubleNewlineSep (Lists.concat [+ [+ package],+ (Lists.map statToExpr stats)]))++scalaFloatLiteralText :: String -> String -> String -> String+scalaFloatLiteralText prefix suffix s =+ Logic.ifElse (Equality.equal s "NaN") (Strings.cat2 prefix ".NaN") (Logic.ifElse (Equality.equal s "Infinity") (Strings.cat2 prefix ".PositiveInfinity") (Logic.ifElse (Equality.equal s "-Infinity") (Strings.cat2 prefix ".NegativeInfinity") (Strings.cat2 s suffix)))++-- | Convert a statement to an expression+statToExpr :: Syntax.Stat -> Ast.Expr+statToExpr stat =+ case stat of+ Syntax.StatTerm v0 -> termToExpr v0+ Syntax.StatDefn v0 -> defnToExpr v0+ Syntax.StatImportExport v0 -> importExportStatToExpr v0++-- | Convert a term to an expression+termToExpr :: Syntax.Data -> Ast.Expr+termToExpr term =+ case term of+ Syntax.DataLit v0 -> litToExpr v0+ Syntax.DataRef v0 -> dataRefToExpr v0+ Syntax.DataApply v0 ->+ let fun = Syntax.applyDataFun v0+ args = Syntax.applyDataArgs v0+ in (Serialization.noSep [+ termToExpr fun,+ (Serialization.parenListAdaptive (Lists.map termToExpr args))])+ Syntax.DataAssign v0 ->+ let lhs = Syntax.assignDataLhs v0+ rhs = Syntax.assignDataRhs v0+ in (Serialization.spaceSep [+ termToExpr lhs,+ (Serialization.cst "->"),+ (termToExpr rhs)])+ Syntax.DataTuple v0 -> Serialization.parenListAdaptive (Lists.map termToExpr (Syntax.tupleDataArgs v0))+ Syntax.DataMatch v0 ->+ let expr = Syntax.matchDataExpr v0+ mCases = Syntax.matchDataCases v0+ in (Serialization.ifx matchOp (termToExpr expr) (Serialization.newlineSep (Lists.map caseToExpr mCases)))+ Syntax.DataFunction v0 -> dataFunctionToExpr v0+ Syntax.DataBlock v0 ->+ let stats = Syntax.blockDataStats v0+ in (Serialization.curlyBlock Serialization.fullBlockStyle (Serialization.newlineSep (Lists.map statToExpr stats)))++-- | Convert a type name to an expression+typeNameToExpr :: Syntax.NameType -> Ast.Expr+typeNameToExpr tn = Serialization.cst (Syntax.nameTypeValue tn)++-- | Convert a type parameter to an expression+typeParamToExpr :: Syntax.ParamType -> Ast.Expr+typeParamToExpr tp = nameToExpr (Syntax.paramTypeName tp)++-- | Convert a type to an expression+typeToExpr :: Syntax.Type -> Ast.Expr+typeToExpr typ =+ case typ of+ Syntax.TypeRef v0 -> case v0 of+ Syntax.RefTypeName v1 -> typeNameToExpr v1+ Syntax.TypeApply v0 ->+ let fun = Syntax.applyTypeTpe v0+ args = Syntax.applyTypeArgs v0+ in (Serialization.noSep [+ typeToExpr fun,+ (Serialization.bracketList Serialization.inlineStyle (Lists.map typeToExpr args))])+ Syntax.TypeFunction v0 ->+ let cod = Syntax.functionTypeRes v0+ dom = Optionals.fromOptional cod (Lists.maybeHead (Syntax.functionTypeParams v0))+ in (Serialization.ifx functionArrowOp (typeToExpr dom) (typeToExpr cod))+ Syntax.TypeLambda v0 ->+ let params = Syntax.lambdaTypeTparams v0+ body = Syntax.lambdaTypeTpe v0+ in (Serialization.noSep [+ typeToExpr body,+ (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr params))])+ Syntax.TypeVar v0 -> typeNameToExpr (Syntax.varTypeName v0)
+ src/main/haskell/Hydra/Scala/Syntax.hs view
@@ -0,0 +1,2128 @@+-- Note: this is an automatically generated file. Do not edit.++-- | A Scala syntax model for Hydra, anchored on Scalameta (https://scalameta.org). Departs from Scalameta where Hydra's needs differ: Term is renamed to Data, the FunctionType/FunctionData wrappers are flattened, and arms Hydra never emits (xml literals, quasiquote/macro forms) are omitted.++module Hydra.Scala.Syntax where++import qualified Hydra.Core as Core+import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Int as I++-- | A wrapper for strings used in scala.Predef contexts.+newtype PredefString =+ PredefString {+ unPredefString :: String}+ deriving (Eq, Ord, Read, Show)++_PredefString = Core.Name "hydra.scala.syntax.PredefString"++-- | A Scala 2 symbol literal (corresponds to scala.Symbol).+data ScalaSymbol =+ ScalaSymbol {+ scalaSymbolName :: String}+ deriving (Eq, Ord, Read, Show)++_ScalaSymbol = Core.Name "hydra.scala.syntax.ScalaSymbol"++_ScalaSymbol_name = Core.Name "name"++-- | The root of the Scalameta tree hierarchy. Each arm names a major AST category.+data Tree =+ TreeRef Ref |+ TreeStat Stat |+ TreeType Type |+ TreeBounds TypeBounds |+ TreePat Pat |+ TreeMember Member |+ TreeCtor Ctor |+ TreeTemplate Template |+ TreeMod Mod |+ TreeEnumerator Enumerator |+ TreeImporter Importer |+ TreeImportee Importee |+ TreeCaseTree CaseTree |+ TreeSource Source+ deriving (Eq, Ord, Read, Show)++_Tree = Core.Name "hydra.scala.syntax.Tree"++_Tree_ref = Core.Name "ref"++_Tree_stat = Core.Name "stat"++_Tree_type = Core.Name "type"++_Tree_bounds = Core.Name "bounds"++_Tree_pat = Core.Name "pat"++_Tree_member = Core.Name "member"++_Tree_ctor = Core.Name "ctor"++_Tree_template = Core.Name "template"++_Tree_mod = Core.Name "mod"++_Tree_enumerator = Core.Name "enumerator"++_Tree_importer = Core.Name "importer"++_Tree_importee = Core.Name "importee"++_Tree_caseTree = Core.Name "caseTree"++_Tree_source = Core.Name "source"++data Ref =+ RefName Name |+ RefInit Init+ deriving (Eq, Ord, Read, Show)++_Ref = Core.Name "hydra.scala.syntax.Ref"++_Ref_name = Core.Name "name"++_Ref_init = Core.Name "init"++data Stat =+ StatTerm Data |+ StatDecl Decl |+ StatDefn Defn |+ StatImportExport ImportExportStat+ deriving (Eq, Ord, Read, Show)++_Stat = Core.Name "hydra.scala.syntax.Stat"++_Stat_term = Core.Name "term"++_Stat_decl = Core.Name "decl"++_Stat_defn = Core.Name "defn"++_Stat_importExport = Core.Name "importExport"++data Name =+ NameValue String |+ NameAnonymous |+ NameIndeterminate PredefString+ deriving (Eq, Ord, Read, Show)++_Name = Core.Name "hydra.scala.syntax.Name"++_Name_value = Core.Name "value"++_Name_anonymous = Core.Name "anonymous"++_Name_indeterminate = Core.Name "indeterminate"++data Lit =+ LitNull |+ LitInt Int |+ LitDouble Double |+ LitFloat Float |+ LitByte I.Int8 |+ LitShort I.Int16 |+ LitChar Int |+ LitLong I.Int64 |+ LitBoolean Bool |+ LitUnit |+ LitString String |+ LitBytes [Int] |+ LitSymbol ScalaSymbol+ deriving (Eq, Ord, Read, Show)++_Lit = Core.Name "hydra.scala.syntax.Lit"++_Lit_null = Core.Name "null"++_Lit_int = Core.Name "int"++_Lit_double = Core.Name "double"++_Lit_float = Core.Name "float"++_Lit_byte = Core.Name "byte"++_Lit_short = Core.Name "short"++_Lit_char = Core.Name "char"++_Lit_long = Core.Name "long"++_Lit_boolean = Core.Name "boolean"++_Lit_unit = Core.Name "unit"++_Lit_string = Core.Name "string"++_Lit_bytes = Core.Name "bytes"++_Lit_symbol = Core.Name "symbol"++data Data =+ DataLit Lit |+ DataRef RefData |+ DataInterpolate InterpolateData |+ DataApply ApplyData |+ DataApplyUsing ApplyUsingData |+ DataApplyType ApplyTypeData |+ DataAssign AssignData |+ DataReturn ReturnData |+ DataThrow ThrowData |+ DataAscribe AscribeData |+ DataAnnotate AnnotateData |+ DataTuple TupleData |+ DataBlock BlockData |+ DataEndMarker EndMarkerData |+ DataIf IfData |+ DataMatch MatchData |+ DataTry TryData |+ DataTryWithHandler TryWithHandlerData |+ DataFunction FunctionData |+ DataContextFunction ContextFunctionData |+ DataPolyFunction PolyFunctionData |+ DataPartialFunction PartialFunctionData |+ DataWhile WhileData |+ DataDo DoData |+ DataFor ForData |+ DataForYield ForYieldData |+ DataNew NewData |+ DataNewAnonymous NewAnonymousData |+ DataPlaceholder |+ DataEta EtaData |+ DataRepeated RepeatedData |+ DataParam ParamData+ deriving (Eq, Ord, Read, Show)++_Data = Core.Name "hydra.scala.syntax.Data"++_Data_lit = Core.Name "lit"++_Data_ref = Core.Name "ref"++_Data_interpolate = Core.Name "interpolate"++_Data_apply = Core.Name "apply"++_Data_applyUsing = Core.Name "applyUsing"++_Data_applyType = Core.Name "applyType"++_Data_assign = Core.Name "assign"++_Data_return = Core.Name "return"++_Data_throw = Core.Name "throw"++_Data_ascribe = Core.Name "ascribe"++_Data_annotate = Core.Name "annotate"++_Data_tuple = Core.Name "tuple"++_Data_block = Core.Name "block"++_Data_endMarker = Core.Name "endMarker"++_Data_if = Core.Name "if"++_Data_match = Core.Name "match"++_Data_try = Core.Name "try"++_Data_tryWithHandler = Core.Name "tryWithHandler"++_Data_function = Core.Name "function"++_Data_contextFunction = Core.Name "contextFunction"++_Data_polyFunction = Core.Name "polyFunction"++_Data_partialFunction = Core.Name "partialFunction"++_Data_while = Core.Name "while"++_Data_do = Core.Name "do"++_Data_for = Core.Name "for"++_Data_forYield = Core.Name "forYield"++_Data_new = Core.Name "new"++_Data_newAnonymous = Core.Name "newAnonymous"++_Data_placeholder = Core.Name "placeholder"++_Data_eta = Core.Name "eta"++_Data_repeated = Core.Name "repeated"++_Data_param = Core.Name "param"++data RefData =+ RefDataThis ThisData |+ RefDataSuper SuperData |+ RefDataName NameData |+ RefDataAnonymous AnonymousData |+ RefDataSelect SelectData |+ RefDataApplyUnary ApplyUnaryData+ deriving (Eq, Ord, Read, Show)++_RefData = Core.Name "hydra.scala.syntax.RefData"++_RefData_this = Core.Name "this"++_RefData_super = Core.Name "super"++_RefData_name = Core.Name "name"++_RefData_anonymous = Core.Name "anonymous"++_RefData_select = Core.Name "select"++_RefData_applyUnary = Core.Name "applyUnary"++newtype ThisData =+ ThisData {+ unThisData :: ()}+ deriving (Eq, Ord, Read, Show)++_ThisData = Core.Name "hydra.scala.syntax.ThisData"++data SuperData =+ SuperData {+ superDataThisp :: Name,+ superDataSuperp :: Name}+ deriving (Eq, Ord, Read, Show)++_SuperData = Core.Name "hydra.scala.syntax.SuperData"++_SuperData_thisp = Core.Name "thisp"++_SuperData_superp = Core.Name "superp"++data NameData =+ NameData {+ nameDataValue :: PredefString}+ deriving (Eq, Ord, Read, Show)++_NameData = Core.Name "hydra.scala.syntax.NameData"++_NameData_value = Core.Name "value"++newtype AnonymousData =+ AnonymousData {+ unAnonymousData :: ()}+ deriving (Eq, Ord, Read, Show)++_AnonymousData = Core.Name "hydra.scala.syntax.AnonymousData"++data SelectData =+ SelectData {+ selectDataQual :: Data,+ selectDataName :: NameData}+ deriving (Eq, Ord, Read, Show)++_SelectData = Core.Name "hydra.scala.syntax.SelectData"++_SelectData_qual = Core.Name "qual"++_SelectData_name = Core.Name "name"++data InterpolateData =+ InterpolateData {+ interpolateDataPrefix :: NameData,+ interpolateDataParts :: [Lit],+ interpolateDataArgs :: [Data]}+ deriving (Eq, Ord, Read, Show)++_InterpolateData = Core.Name "hydra.scala.syntax.InterpolateData"++_InterpolateData_prefix = Core.Name "prefix"++_InterpolateData_parts = Core.Name "parts"++_InterpolateData_args = Core.Name "args"++data ApplyData =+ ApplyData {+ applyDataFun :: Data,+ applyDataArgs :: [Data]}+ deriving (Eq, Ord, Read, Show)++_ApplyData = Core.Name "hydra.scala.syntax.ApplyData"++_ApplyData_fun = Core.Name "fun"++_ApplyData_args = Core.Name "args"++data ApplyUsingData =+ ApplyUsingData {+ applyUsingDataFun :: Data,+ applyUsingDataTargs :: [Data]}+ deriving (Eq, Ord, Read, Show)++_ApplyUsingData = Core.Name "hydra.scala.syntax.ApplyUsingData"++_ApplyUsingData_fun = Core.Name "fun"++_ApplyUsingData_targs = Core.Name "targs"++data ApplyTypeData =+ ApplyTypeData {+ applyTypeDataLhs :: Data,+ applyTypeDataOp :: NameData,+ applyTypeDataTargs :: [Type],+ applyTypeDataArgs :: [Data]}+ deriving (Eq, Ord, Read, Show)++_ApplyTypeData = Core.Name "hydra.scala.syntax.ApplyTypeData"++_ApplyTypeData_lhs = Core.Name "lhs"++_ApplyTypeData_op = Core.Name "op"++_ApplyTypeData_targs = Core.Name "targs"++_ApplyTypeData_args = Core.Name "args"++data ApplyInfixData =+ ApplyInfixData {+ applyInfixDataLhs :: Data,+ applyInfixDataOp :: NameData,+ applyInfixDataTargs :: [Type],+ applyInfixDataArgs :: [Data]}+ deriving (Eq, Ord, Read, Show)++_ApplyInfixData = Core.Name "hydra.scala.syntax.ApplyInfixData"++_ApplyInfixData_lhs = Core.Name "lhs"++_ApplyInfixData_op = Core.Name "op"++_ApplyInfixData_targs = Core.Name "targs"++_ApplyInfixData_args = Core.Name "args"++data ApplyUnaryData =+ ApplyUnaryData {+ applyUnaryDataOp :: NameData,+ applyUnaryDataArg :: Data}+ deriving (Eq, Ord, Read, Show)++_ApplyUnaryData = Core.Name "hydra.scala.syntax.ApplyUnaryData"++_ApplyUnaryData_op = Core.Name "op"++_ApplyUnaryData_arg = Core.Name "arg"++data AssignData =+ AssignData {+ assignDataLhs :: Data,+ assignDataRhs :: Data}+ deriving (Eq, Ord, Read, Show)++_AssignData = Core.Name "hydra.scala.syntax.AssignData"++_AssignData_lhs = Core.Name "lhs"++_AssignData_rhs = Core.Name "rhs"++data ReturnData =+ ReturnData {+ returnDataExpr :: Data}+ deriving (Eq, Ord, Read, Show)++_ReturnData = Core.Name "hydra.scala.syntax.ReturnData"++_ReturnData_expr = Core.Name "expr"++data ThrowData =+ ThrowData {+ throwDataExpr :: Data}+ deriving (Eq, Ord, Read, Show)++_ThrowData = Core.Name "hydra.scala.syntax.ThrowData"++_ThrowData_expr = Core.Name "expr"++data AscribeData =+ AscribeData {+ ascribeDataExpr :: Data,+ ascribeDataTpe :: Type}+ deriving (Eq, Ord, Read, Show)++_AscribeData = Core.Name "hydra.scala.syntax.AscribeData"++_AscribeData_expr = Core.Name "expr"++_AscribeData_tpe = Core.Name "tpe"++data AnnotateData =+ AnnotateData {+ annotateDataExpr :: Data,+ annotateDataAnnots :: [AnnotMod]}+ deriving (Eq, Ord, Read, Show)++_AnnotateData = Core.Name "hydra.scala.syntax.AnnotateData"++_AnnotateData_expr = Core.Name "expr"++_AnnotateData_annots = Core.Name "annots"++data TupleData =+ TupleData {+ tupleDataArgs :: [Data]}+ deriving (Eq, Ord, Read, Show)++_TupleData = Core.Name "hydra.scala.syntax.TupleData"++_TupleData_args = Core.Name "args"++data BlockData =+ BlockData {+ blockDataStats :: [Stat]}+ deriving (Eq, Ord, Read, Show)++_BlockData = Core.Name "hydra.scala.syntax.BlockData"++_BlockData_stats = Core.Name "stats"++data EndMarkerData =+ EndMarkerData {+ endMarkerDataName :: NameData}+ deriving (Eq, Ord, Read, Show)++_EndMarkerData = Core.Name "hydra.scala.syntax.EndMarkerData"++_EndMarkerData_name = Core.Name "name"++data IfData =+ IfData {+ ifDataCond :: Data,+ ifDataThenp :: Data,+ ifDataElsep :: Data}+ deriving (Eq, Ord, Read, Show)++_IfData = Core.Name "hydra.scala.syntax.IfData"++_IfData_cond = Core.Name "cond"++_IfData_thenp = Core.Name "thenp"++_IfData_elsep = Core.Name "elsep"++data MatchData =+ MatchData {+ matchDataExpr :: Data,+ matchDataCases :: [Case]}+ deriving (Eq, Ord, Read, Show)++_MatchData = Core.Name "hydra.scala.syntax.MatchData"++_MatchData_expr = Core.Name "expr"++_MatchData_cases = Core.Name "cases"++data TryData =+ TryData {+ tryDataExpr :: Data,+ tryDataCatchp :: [Case],+ tryDataFinallyp :: (Maybe Data)}+ deriving (Eq, Ord, Read, Show)++_TryData = Core.Name "hydra.scala.syntax.TryData"++_TryData_expr = Core.Name "expr"++_TryData_catchp = Core.Name "catchp"++_TryData_finallyp = Core.Name "finallyp"++data TryWithHandlerData =+ TryWithHandlerData {+ tryWithHandlerDataExpr :: Data,+ tryWithHandlerDataCatchp :: Data,+ tryWithHandlerDataFinallyp :: (Maybe Data)}+ deriving (Eq, Ord, Read, Show)++_TryWithHandlerData = Core.Name "hydra.scala.syntax.TryWithHandlerData"++_TryWithHandlerData_expr = Core.Name "expr"++_TryWithHandlerData_catchp = Core.Name "catchp"++_TryWithHandlerData_finallyp = Core.Name "finallyp"++data ContextFunctionData =+ ContextFunctionData {+ contextFunctionDataParams :: [ParamData],+ contextFunctionDataBody :: Data}+ deriving (Eq, Ord, Read, Show)++_ContextFunctionData = Core.Name "hydra.scala.syntax.ContextFunctionData"++_ContextFunctionData_params = Core.Name "params"++_ContextFunctionData_body = Core.Name "body"++data FunctionData =+ FunctionData {+ functionDataParams :: [ParamData],+ functionDataBody :: Data}+ deriving (Eq, Ord, Read, Show)++_FunctionData = Core.Name "hydra.scala.syntax.FunctionData"++_FunctionData_params = Core.Name "params"++_FunctionData_body = Core.Name "body"++data PolyFunctionData =+ PolyFunctionData {+ polyFunctionDataTparams :: [ParamType],+ polyFunctionDataBody :: Data}+ deriving (Eq, Ord, Read, Show)++_PolyFunctionData = Core.Name "hydra.scala.syntax.PolyFunctionData"++_PolyFunctionData_tparams = Core.Name "tparams"++_PolyFunctionData_body = Core.Name "body"++data PartialFunctionData =+ PartialFunctionData {+ partialFunctionDataCases :: [Case]}+ deriving (Eq, Ord, Read, Show)++_PartialFunctionData = Core.Name "hydra.scala.syntax.PartialFunctionData"++_PartialFunctionData_cases = Core.Name "cases"++data WhileData =+ WhileData {+ whileDataExpr :: Data,+ whileDataBody :: Data}+ deriving (Eq, Ord, Read, Show)++_WhileData = Core.Name "hydra.scala.syntax.WhileData"++_WhileData_expr = Core.Name "expr"++_WhileData_body = Core.Name "body"++data DoData =+ DoData {+ doDataBody :: Data,+ doDataExpr :: Data}+ deriving (Eq, Ord, Read, Show)++_DoData = Core.Name "hydra.scala.syntax.DoData"++_DoData_body = Core.Name "body"++_DoData_expr = Core.Name "expr"++data ForData =+ ForData {+ forDataEnums :: [Enumerator]}+ deriving (Eq, Ord, Read, Show)++_ForData = Core.Name "hydra.scala.syntax.ForData"++_ForData_enums = Core.Name "enums"++data ForYieldData =+ ForYieldData {+ forYieldDataEnums :: [Enumerator]}+ deriving (Eq, Ord, Read, Show)++_ForYieldData = Core.Name "hydra.scala.syntax.ForYieldData"++_ForYieldData_enums = Core.Name "enums"++data NewData =+ NewData {+ newDataInit :: Init}+ deriving (Eq, Ord, Read, Show)++_NewData = Core.Name "hydra.scala.syntax.NewData"++_NewData_init = Core.Name "init"++data NewAnonymousData =+ NewAnonymousData {+ newAnonymousDataTempl :: Template}+ deriving (Eq, Ord, Read, Show)++_NewAnonymousData = Core.Name "hydra.scala.syntax.NewAnonymousData"++_NewAnonymousData_templ = Core.Name "templ"++data EtaData =+ EtaData {+ etaDataExpr :: Data}+ deriving (Eq, Ord, Read, Show)++_EtaData = Core.Name "hydra.scala.syntax.EtaData"++_EtaData_expr = Core.Name "expr"++data RepeatedData =+ RepeatedData {+ repeatedDataExpr :: Data}+ deriving (Eq, Ord, Read, Show)++_RepeatedData = Core.Name "hydra.scala.syntax.RepeatedData"++_RepeatedData_expr = Core.Name "expr"++data ParamData =+ ParamData {+ paramDataMods :: [Mod],+ paramDataName :: Name,+ paramDataDecltpe :: (Maybe Type),+ paramDataDefault :: (Maybe Data)}+ deriving (Eq, Ord, Read, Show)++_ParamData = Core.Name "hydra.scala.syntax.ParamData"++_ParamData_mods = Core.Name "mods"++_ParamData_name = Core.Name "name"++_ParamData_decltpe = Core.Name "decltpe"++_ParamData_default = Core.Name "default"++data Type =+ TypeRef RefType |+ TypeAnonymousName AnonymousNameType |+ TypeApply ApplyType |+ TypeApplyInfix ApplyInfixType |+ TypeFunction FunctionType |+ TypeContextFunction ContextFunctionType |+ TypePolyFunction PolyFunctionType |+ TypeImplicitFunction ImplicitFunctionType |+ TypeTuple TupleType |+ TypeWith WithType |+ TypeAnd AndType |+ TypeOr OrType |+ TypeRefine RefineType |+ TypeExistential ExistentialType |+ TypeAnnotate AnnotateType |+ TypeLambda LambdaType |+ TypeMethod MethodType |+ TypePlaceholder PlaceholderType |+ TypeByName ByNameType |+ TypeRepeated RepeatedType |+ TypeVar VarType |+ TypeTypedParam TypedParamType |+ TypeMatch MatchType+ deriving (Eq, Ord, Read, Show)++_Type = Core.Name "hydra.scala.syntax.Type"++_Type_ref = Core.Name "ref"++_Type_anonymousName = Core.Name "anonymousName"++_Type_apply = Core.Name "apply"++_Type_applyInfix = Core.Name "applyInfix"++_Type_function = Core.Name "function"++_Type_contextFunction = Core.Name "contextFunction"++_Type_polyFunction = Core.Name "polyFunction"++_Type_implicitFunction = Core.Name "implicitFunction"++_Type_tuple = Core.Name "tuple"++_Type_with = Core.Name "with"++_Type_and = Core.Name "and"++_Type_or = Core.Name "or"++_Type_refine = Core.Name "refine"++_Type_existential = Core.Name "existential"++_Type_annotate = Core.Name "annotate"++_Type_lambda = Core.Name "lambda"++_Type_method = Core.Name "method"++_Type_placeholder = Core.Name "placeholder"++_Type_byName = Core.Name "byName"++_Type_repeated = Core.Name "repeated"++_Type_var = Core.Name "var"++_Type_typedParam = Core.Name "typedParam"++_Type_match = Core.Name "match"++data RefType =+ RefTypeName NameType |+ RefTypeSelect SelectType |+ RefTypeProject ProjectType |+ RefTypeSingleton SingletonType+ deriving (Eq, Ord, Read, Show)++_RefType = Core.Name "hydra.scala.syntax.RefType"++_RefType_name = Core.Name "name"++_RefType_select = Core.Name "select"++_RefType_project = Core.Name "project"++_RefType_singleton = Core.Name "singleton"++data NameType =+ NameType {+ nameTypeValue :: String}+ deriving (Eq, Ord, Read, Show)++_NameType = Core.Name "hydra.scala.syntax.NameType"++_NameType_value = Core.Name "value"++newtype AnonymousNameType =+ AnonymousNameType {+ unAnonymousNameType :: ()}+ deriving (Eq, Ord, Read, Show)++_AnonymousNameType = Core.Name "hydra.scala.syntax.AnonymousNameType"++data SelectType =+ SelectType {+ selectTypeQual :: RefData,+ selectTypeName :: NameType}+ deriving (Eq, Ord, Read, Show)++_SelectType = Core.Name "hydra.scala.syntax.SelectType"++_SelectType_qual = Core.Name "qual"++_SelectType_name = Core.Name "name"++data ProjectType =+ ProjectType {+ projectTypeQual :: Type,+ projectTypeName :: NameType}+ deriving (Eq, Ord, Read, Show)++_ProjectType = Core.Name "hydra.scala.syntax.ProjectType"++_ProjectType_qual = Core.Name "qual"++_ProjectType_name = Core.Name "name"++data SingletonType =+ SingletonType {+ singletonTypeRef :: RefData}+ deriving (Eq, Ord, Read, Show)++_SingletonType = Core.Name "hydra.scala.syntax.SingletonType"++_SingletonType_ref = Core.Name "ref"++data ApplyType =+ ApplyType {+ applyTypeTpe :: Type,+ applyTypeArgs :: [Type]}+ deriving (Eq, Ord, Read, Show)++_ApplyType = Core.Name "hydra.scala.syntax.ApplyType"++_ApplyType_tpe = Core.Name "tpe"++_ApplyType_args = Core.Name "args"++data ApplyInfixType =+ ApplyInfixType {+ applyInfixTypeLhs :: Type,+ applyInfixTypeOp :: NameType,+ applyInfixTypeRhs :: Type}+ deriving (Eq, Ord, Read, Show)++_ApplyInfixType = Core.Name "hydra.scala.syntax.ApplyInfixType"++_ApplyInfixType_lhs = Core.Name "lhs"++_ApplyInfixType_op = Core.Name "op"++_ApplyInfixType_rhs = Core.Name "rhs"++data FunctionType =+ FunctionType {+ functionTypeParams :: [Type],+ functionTypeRes :: Type}+ deriving (Eq, Ord, Read, Show)++_FunctionType = Core.Name "hydra.scala.syntax.FunctionType"++_FunctionType_params = Core.Name "params"++_FunctionType_res = Core.Name "res"++data PolyFunctionType =+ PolyFunctionType {+ polyFunctionTypeTparams :: [ParamType],+ polyFunctionTypeTpe :: Type}+ deriving (Eq, Ord, Read, Show)++_PolyFunctionType = Core.Name "hydra.scala.syntax.PolyFunctionType"++_PolyFunctionType_tparams = Core.Name "tparams"++_PolyFunctionType_tpe = Core.Name "tpe"++data ContextFunctionType =+ ContextFunctionType {+ contextFunctionTypeParams :: [Type],+ contextFunctionTypeRes :: Type}+ deriving (Eq, Ord, Read, Show)++_ContextFunctionType = Core.Name "hydra.scala.syntax.ContextFunctionType"++_ContextFunctionType_params = Core.Name "params"++_ContextFunctionType_res = Core.Name "res"++data ImplicitFunctionType =+ ImplicitFunctionType {+ implicitFunctionTypeParams :: [Type],+ implicitFunctionTypeRes :: Type}+ deriving (Eq, Ord, Read, Show)++_ImplicitFunctionType = Core.Name "hydra.scala.syntax.ImplicitFunctionType"++_ImplicitFunctionType_params = Core.Name "params"++_ImplicitFunctionType_res = Core.Name "res"++data TupleType =+ TupleType {+ tupleTypeArgs :: [Type]}+ deriving (Eq, Ord, Read, Show)++_TupleType = Core.Name "hydra.scala.syntax.TupleType"++_TupleType_args = Core.Name "args"++data WithType =+ WithType {+ withTypeLhs :: Type,+ withTypeRhs :: Type}+ deriving (Eq, Ord, Read, Show)++_WithType = Core.Name "hydra.scala.syntax.WithType"++_WithType_lhs = Core.Name "lhs"++_WithType_rhs = Core.Name "rhs"++data AndType =+ AndType {+ andTypeLhs :: Type,+ andTypeRhs :: Type}+ deriving (Eq, Ord, Read, Show)++_AndType = Core.Name "hydra.scala.syntax.AndType"++_AndType_lhs = Core.Name "lhs"++_AndType_rhs = Core.Name "rhs"++data OrType =+ OrType {+ orTypeLhs :: Type,+ orTypeRhs :: Type}+ deriving (Eq, Ord, Read, Show)++_OrType = Core.Name "hydra.scala.syntax.OrType"++_OrType_lhs = Core.Name "lhs"++_OrType_rhs = Core.Name "rhs"++data RefineType =+ RefineType {+ refineTypeTpe :: (Maybe Type),+ refineTypeStats :: [Stat]}+ deriving (Eq, Ord, Read, Show)++_RefineType = Core.Name "hydra.scala.syntax.RefineType"++_RefineType_tpe = Core.Name "tpe"++_RefineType_stats = Core.Name "stats"++data ExistentialType =+ ExistentialType {+ existentialTypeTpe :: Type,+ existentialTypeStats :: [Stat]}+ deriving (Eq, Ord, Read, Show)++_ExistentialType = Core.Name "hydra.scala.syntax.ExistentialType"++_ExistentialType_tpe = Core.Name "tpe"++_ExistentialType_stats = Core.Name "stats"++data AnnotateType =+ AnnotateType {+ annotateTypeTpe :: Type,+ annotateTypeAnnots :: [AnnotMod]}+ deriving (Eq, Ord, Read, Show)++_AnnotateType = Core.Name "hydra.scala.syntax.AnnotateType"++_AnnotateType_tpe = Core.Name "tpe"++_AnnotateType_annots = Core.Name "annots"++data LambdaType =+ LambdaType {+ lambdaTypeTparams :: [ParamType],+ lambdaTypeTpe :: Type}+ deriving (Eq, Ord, Read, Show)++_LambdaType = Core.Name "hydra.scala.syntax.LambdaType"++_LambdaType_tparams = Core.Name "tparams"++_LambdaType_tpe = Core.Name "tpe"++data MethodType =+ MethodType {+ methodTypeParamss :: [[ParamData]],+ methodTypeTpe :: Type}+ deriving (Eq, Ord, Read, Show)++_MethodType = Core.Name "hydra.scala.syntax.MethodType"++_MethodType_paramss = Core.Name "paramss"++_MethodType_tpe = Core.Name "tpe"++data PlaceholderType =+ PlaceholderType {+ placeholderTypeBounds :: TypeBounds}+ deriving (Eq, Ord, Read, Show)++_PlaceholderType = Core.Name "hydra.scala.syntax.PlaceholderType"++_PlaceholderType_bounds = Core.Name "bounds"++data TypeBounds =+ TypeBounds {+ typeBoundsLo :: (Maybe Type),+ typeBoundsHi :: (Maybe Type)}+ deriving (Eq, Ord, Read, Show)++_TypeBounds = Core.Name "hydra.scala.syntax.TypeBounds"++_TypeBounds_lo = Core.Name "lo"++_TypeBounds_hi = Core.Name "hi"++data ByNameType =+ ByNameType {+ byNameTypeTpe :: Type}+ deriving (Eq, Ord, Read, Show)++_ByNameType = Core.Name "hydra.scala.syntax.ByNameType"++_ByNameType_tpe = Core.Name "tpe"++data RepeatedType =+ RepeatedType {+ repeatedTypeTpe :: Type}+ deriving (Eq, Ord, Read, Show)++_RepeatedType = Core.Name "hydra.scala.syntax.RepeatedType"++_RepeatedType_tpe = Core.Name "tpe"++data VarType =+ VarType {+ varTypeName :: NameType}+ deriving (Eq, Ord, Read, Show)++_VarType = Core.Name "hydra.scala.syntax.VarType"++_VarType_name = Core.Name "name"++data TypedParamType =+ TypedParamType {+ typedParamTypeName :: Name,+ typedParamTypeTyp :: Type}+ deriving (Eq, Ord, Read, Show)++_TypedParamType = Core.Name "hydra.scala.syntax.TypedParamType"++_TypedParamType_name = Core.Name "name"++_TypedParamType_typ = Core.Name "typ"++data ParamType =+ ParamType {+ paramTypeMods :: [Mod],+ paramTypeName :: Name,+ paramTypeTparams :: [ParamType],+ paramTypeTbounds :: [TypeBounds],+ paramTypeVbounds :: [Type],+ paramTypeCbounds :: [Type]}+ deriving (Eq, Ord, Read, Show)++_ParamType = Core.Name "hydra.scala.syntax.ParamType"++_ParamType_mods = Core.Name "mods"++_ParamType_name = Core.Name "name"++_ParamType_tparams = Core.Name "tparams"++_ParamType_tbounds = Core.Name "tbounds"++_ParamType_vbounds = Core.Name "vbounds"++_ParamType_cbounds = Core.Name "cbounds"++data MatchType =+ MatchType {+ matchTypeTpe :: Type,+ matchTypeCases :: [TypeCase]}+ deriving (Eq, Ord, Read, Show)++_MatchType = Core.Name "hydra.scala.syntax.MatchType"++_MatchType_tpe = Core.Name "tpe"++_MatchType_cases = Core.Name "cases"++data Pat =+ PatVar VarPat |+ PatWildcard |+ PatSeqWildcard |+ PatBind BindPat |+ PatAlternative AlternativePat |+ PatTuple TuplePat |+ PatRepeated RepeatedPat |+ PatExtract ExtractPat |+ PatExtractInfix ExtractInfixPat |+ PatInterpolate InterpolatePat |+ PatTyped TypedPat |+ PatGiven GivenPat+ deriving (Eq, Ord, Read, Show)++_Pat = Core.Name "hydra.scala.syntax.Pat"++_Pat_var = Core.Name "var"++_Pat_wildcard = Core.Name "wildcard"++_Pat_seqWildcard = Core.Name "seqWildcard"++_Pat_bind = Core.Name "bind"++_Pat_alternative = Core.Name "alternative"++_Pat_tuple = Core.Name "tuple"++_Pat_repeated = Core.Name "repeated"++_Pat_extract = Core.Name "extract"++_Pat_extractInfix = Core.Name "extractInfix"++_Pat_interpolate = Core.Name "interpolate"++_Pat_typed = Core.Name "typed"++_Pat_given = Core.Name "given"++data VarPat =+ VarPat {+ varPatName :: NameData}+ deriving (Eq, Ord, Read, Show)++_VarPat = Core.Name "hydra.scala.syntax.VarPat"++_VarPat_name = Core.Name "name"++data BindPat =+ BindPat {+ bindPatLhs :: Pat,+ bindPatRhs :: Pat}+ deriving (Eq, Ord, Read, Show)++_BindPat = Core.Name "hydra.scala.syntax.BindPat"++_BindPat_lhs = Core.Name "lhs"++_BindPat_rhs = Core.Name "rhs"++data AlternativePat =+ AlternativePat {+ alternativePatLhs :: Pat,+ alternativePatRhs :: Pat}+ deriving (Eq, Ord, Read, Show)++_AlternativePat = Core.Name "hydra.scala.syntax.AlternativePat"++_AlternativePat_lhs = Core.Name "lhs"++_AlternativePat_rhs = Core.Name "rhs"++data TuplePat =+ TuplePat {+ tuplePatArgs :: [Pat]}+ deriving (Eq, Ord, Read, Show)++_TuplePat = Core.Name "hydra.scala.syntax.TuplePat"++_TuplePat_args = Core.Name "args"++data RepeatedPat =+ RepeatedPat {+ repeatedPatName :: NameData}+ deriving (Eq, Ord, Read, Show)++_RepeatedPat = Core.Name "hydra.scala.syntax.RepeatedPat"++_RepeatedPat_name = Core.Name "name"++data ExtractPat =+ ExtractPat {+ extractPatFun :: Data,+ extractPatArgs :: [Pat]}+ deriving (Eq, Ord, Read, Show)++_ExtractPat = Core.Name "hydra.scala.syntax.ExtractPat"++_ExtractPat_fun = Core.Name "fun"++_ExtractPat_args = Core.Name "args"++data ExtractInfixPat =+ ExtractInfixPat {+ extractInfixPatLhs :: Pat,+ extractInfixPatOp :: NameData,+ extractInfixPatRhs :: [Pat]}+ deriving (Eq, Ord, Read, Show)++_ExtractInfixPat = Core.Name "hydra.scala.syntax.ExtractInfixPat"++_ExtractInfixPat_lhs = Core.Name "lhs"++_ExtractInfixPat_op = Core.Name "op"++_ExtractInfixPat_rhs = Core.Name "rhs"++data InterpolatePat =+ InterpolatePat {+ interpolatePatPrefix :: NameData,+ interpolatePatParts :: [Lit]}+ deriving (Eq, Ord, Read, Show)++_InterpolatePat = Core.Name "hydra.scala.syntax.InterpolatePat"++_InterpolatePat_prefix = Core.Name "prefix"++_InterpolatePat_parts = Core.Name "parts"++data TypedPat =+ TypedPat {+ typedPatLhs :: Pat,+ typedPatRhs :: Type}+ deriving (Eq, Ord, Read, Show)++_TypedPat = Core.Name "hydra.scala.syntax.TypedPat"++_TypedPat_lhs = Core.Name "lhs"++_TypedPat_rhs = Core.Name "rhs"++data GivenPat =+ GivenPat {+ givenPatTpe :: Type}+ deriving (Eq, Ord, Read, Show)++_GivenPat = Core.Name "hydra.scala.syntax.GivenPat"++_GivenPat_tpe = Core.Name "tpe"++data Member =+ MemberTerm DataMember |+ MemberType TypeMember |+ MemberTermParam ParamData |+ MemberTypeParam ParamType |+ MemberSelf Self+ deriving (Eq, Ord, Read, Show)++_Member = Core.Name "hydra.scala.syntax.Member"++_Member_term = Core.Name "term"++_Member_type = Core.Name "type"++_Member_termParam = Core.Name "termParam"++_Member_typeParam = Core.Name "typeParam"++_Member_self = Core.Name "self"++data DataMember =+ DataMemberPkg Pkg |+ DataMemberObject ObjectPkg+ deriving (Eq, Ord, Read, Show)++_DataMember = Core.Name "hydra.scala.syntax.DataMember"++_DataMember_pkg = Core.Name "pkg"++_DataMember_object = Core.Name "object"++data TypeMember =+ TypeMember {+ typeMemberName :: NameType}+ deriving (Eq, Ord, Read, Show)++_TypeMember = Core.Name "hydra.scala.syntax.TypeMember"++_TypeMember_name = Core.Name "name"++data Decl =+ DeclVal ValDecl |+ DeclVar VarDecl |+ DeclDef DefDecl |+ DeclType TypeDecl |+ DeclGiven GivenDecl+ deriving (Eq, Ord, Read, Show)++_Decl = Core.Name "hydra.scala.syntax.Decl"++_Decl_val = Core.Name "val"++_Decl_var = Core.Name "var"++_Decl_def = Core.Name "def"++_Decl_type = Core.Name "type"++_Decl_given = Core.Name "given"++data ValDecl =+ ValDecl {+ valDeclMods :: [Mod],+ valDeclPats :: [Pat],+ valDeclDecltpe :: Type}+ deriving (Eq, Ord, Read, Show)++_ValDecl = Core.Name "hydra.scala.syntax.ValDecl"++_ValDecl_mods = Core.Name "mods"++_ValDecl_pats = Core.Name "pats"++_ValDecl_decltpe = Core.Name "decltpe"++data VarDecl =+ VarDecl {+ varDeclMods :: [Mod],+ varDeclPats :: [Pat],+ varDeclDecltpe :: Type}+ deriving (Eq, Ord, Read, Show)++_VarDecl = Core.Name "hydra.scala.syntax.VarDecl"++_VarDecl_mods = Core.Name "mods"++_VarDecl_pats = Core.Name "pats"++_VarDecl_decltpe = Core.Name "decltpe"++data DefDecl =+ DefDecl {+ defDeclMods :: [Mod],+ defDeclName :: NameData,+ defDeclTparams :: [ParamType],+ defDeclParamss :: [[ParamData]],+ defDeclDecltpe :: Type}+ deriving (Eq, Ord, Read, Show)++_DefDecl = Core.Name "hydra.scala.syntax.DefDecl"++_DefDecl_mods = Core.Name "mods"++_DefDecl_name = Core.Name "name"++_DefDecl_tparams = Core.Name "tparams"++_DefDecl_paramss = Core.Name "paramss"++_DefDecl_decltpe = Core.Name "decltpe"++data TypeDecl =+ TypeDecl {+ typeDeclMods :: [Mod],+ typeDeclName :: NameType,+ typeDeclTparams :: [ParamType],+ typeDeclBounds :: TypeBounds}+ deriving (Eq, Ord, Read, Show)++_TypeDecl = Core.Name "hydra.scala.syntax.TypeDecl"++_TypeDecl_mods = Core.Name "mods"++_TypeDecl_name = Core.Name "name"++_TypeDecl_tparams = Core.Name "tparams"++_TypeDecl_bounds = Core.Name "bounds"++data GivenDecl =+ GivenDecl {+ givenDeclMods :: [Mod],+ givenDeclName :: NameData,+ givenDeclTparams :: [ParamType],+ givenDeclSparams :: [[ParamData]],+ givenDeclDecltpe :: Type}+ deriving (Eq, Ord, Read, Show)++_GivenDecl = Core.Name "hydra.scala.syntax.GivenDecl"++_GivenDecl_mods = Core.Name "mods"++_GivenDecl_name = Core.Name "name"++_GivenDecl_tparams = Core.Name "tparams"++_GivenDecl_sparams = Core.Name "sparams"++_GivenDecl_decltpe = Core.Name "decltpe"++data Defn =+ DefnVal ValDefn |+ DefnVar VarDefn |+ DefnGiven GivenDefn |+ DefnEnum EnumDefn |+ DefnEnumCase EnumCaseDefn |+ DefnRepeatedEnumCase RepeatedEnumCaseDefn |+ DefnGivenAlias GivenAliasDefn |+ DefnExtensionGroup ExtensionGroupDefn |+ DefnDef DefDefn |+ DefnType TypeDefn |+ DefnClass ClassDefn |+ DefnTrait TraitDefn |+ DefnObject ObjectDefn+ deriving (Eq, Ord, Read, Show)++_Defn = Core.Name "hydra.scala.syntax.Defn"++_Defn_val = Core.Name "val"++_Defn_var = Core.Name "var"++_Defn_given = Core.Name "given"++_Defn_enum = Core.Name "enum"++_Defn_enumCase = Core.Name "enumCase"++_Defn_repeatedEnumCase = Core.Name "repeatedEnumCase"++_Defn_givenAlias = Core.Name "givenAlias"++_Defn_extensionGroup = Core.Name "extensionGroup"++_Defn_def = Core.Name "def"++_Defn_type = Core.Name "type"++_Defn_class = Core.Name "class"++_Defn_trait = Core.Name "trait"++_Defn_object = Core.Name "object"++data ValDefn =+ ValDefn {+ valDefnMods :: [Mod],+ valDefnPats :: [Pat],+ valDefnDecltpe :: (Maybe Type),+ valDefnRhs :: Data}+ deriving (Eq, Ord, Read, Show)++_ValDefn = Core.Name "hydra.scala.syntax.ValDefn"++_ValDefn_mods = Core.Name "mods"++_ValDefn_pats = Core.Name "pats"++_ValDefn_decltpe = Core.Name "decltpe"++_ValDefn_rhs = Core.Name "rhs"++data VarDefn =+ VarDefn {+ varDefnMods :: [Mod],+ varDefnPats :: [Pat],+ varDefnDecltpe :: Type,+ varDefnRhs :: (Maybe Data)}+ deriving (Eq, Ord, Read, Show)++_VarDefn = Core.Name "hydra.scala.syntax.VarDefn"++_VarDefn_mods = Core.Name "mods"++_VarDefn_pats = Core.Name "pats"++_VarDefn_decltpe = Core.Name "decltpe"++_VarDefn_rhs = Core.Name "rhs"++data GivenDefn =+ GivenDefn {+ givenDefnMods :: [Mod],+ givenDefnName :: Name,+ givenDefnTparams :: [[ParamType]],+ givenDefnSparams :: [[ParamData]],+ givenDefnTempl :: Template}+ deriving (Eq, Ord, Read, Show)++_GivenDefn = Core.Name "hydra.scala.syntax.GivenDefn"++_GivenDefn_mods = Core.Name "mods"++_GivenDefn_name = Core.Name "name"++_GivenDefn_tparams = Core.Name "tparams"++_GivenDefn_sparams = Core.Name "sparams"++_GivenDefn_templ = Core.Name "templ"++data EnumDefn =+ EnumDefn {+ enumDefnMods :: [Mod],+ enumDefnName :: NameType,+ enumDefnTparams :: [ParamType],+ enumDefnCtor :: PrimaryCtor,+ enumDefnTemplate :: Template}+ deriving (Eq, Ord, Read, Show)++_EnumDefn = Core.Name "hydra.scala.syntax.EnumDefn"++_EnumDefn_mods = Core.Name "mods"++_EnumDefn_name = Core.Name "name"++_EnumDefn_tparams = Core.Name "tparams"++_EnumDefn_ctor = Core.Name "ctor"++_EnumDefn_template = Core.Name "template"++data EnumCaseDefn =+ EnumCaseDefn {+ enumCaseDefnMods :: [Mod],+ enumCaseDefnName :: NameData,+ enumCaseDefnTparams :: [ParamType],+ enumCaseDefnCtor :: PrimaryCtor,+ enumCaseDefnInits :: [Init]}+ deriving (Eq, Ord, Read, Show)++_EnumCaseDefn = Core.Name "hydra.scala.syntax.EnumCaseDefn"++_EnumCaseDefn_mods = Core.Name "mods"++_EnumCaseDefn_name = Core.Name "name"++_EnumCaseDefn_tparams = Core.Name "tparams"++_EnumCaseDefn_ctor = Core.Name "ctor"++_EnumCaseDefn_inits = Core.Name "inits"++data RepeatedEnumCaseDefn =+ RepeatedEnumCaseDefn {+ repeatedEnumCaseDefnMods :: [Mod],+ repeatedEnumCaseDefnCases :: [NameData]}+ deriving (Eq, Ord, Read, Show)++_RepeatedEnumCaseDefn = Core.Name "hydra.scala.syntax.RepeatedEnumCaseDefn"++_RepeatedEnumCaseDefn_mods = Core.Name "mods"++_RepeatedEnumCaseDefn_cases = Core.Name "cases"++data GivenAliasDefn =+ GivenAliasDefn {+ givenAliasDefnMods :: [Mod],+ givenAliasDefnName :: Name,+ givenAliasDefnTparams :: [[ParamType]],+ givenAliasDefnSparams :: [[ParamData]],+ givenAliasDefnDecltpe :: Type,+ givenAliasDefnBody :: Data}+ deriving (Eq, Ord, Read, Show)++_GivenAliasDefn = Core.Name "hydra.scala.syntax.GivenAliasDefn"++_GivenAliasDefn_mods = Core.Name "mods"++_GivenAliasDefn_name = Core.Name "name"++_GivenAliasDefn_tparams = Core.Name "tparams"++_GivenAliasDefn_sparams = Core.Name "sparams"++_GivenAliasDefn_decltpe = Core.Name "decltpe"++_GivenAliasDefn_body = Core.Name "body"++data ExtensionGroupDefn =+ ExtensionGroupDefn {+ extensionGroupDefnTparams :: [ParamType],+ extensionGroupDefnParmss :: [[ParamData]],+ extensionGroupDefnBody :: Stat}+ deriving (Eq, Ord, Read, Show)++_ExtensionGroupDefn = Core.Name "hydra.scala.syntax.ExtensionGroupDefn"++_ExtensionGroupDefn_tparams = Core.Name "tparams"++_ExtensionGroupDefn_parmss = Core.Name "parmss"++_ExtensionGroupDefn_body = Core.Name "body"++data DefDefn =+ DefDefn {+ defDefnMods :: [Mod],+ defDefnName :: NameData,+ defDefnTparams :: [ParamType],+ defDefnParamss :: [[ParamData]],+ defDefnDecltpe :: (Maybe Type),+ defDefnBody :: Data}+ deriving (Eq, Ord, Read, Show)++_DefDefn = Core.Name "hydra.scala.syntax.DefDefn"++_DefDefn_mods = Core.Name "mods"++_DefDefn_name = Core.Name "name"++_DefDefn_tparams = Core.Name "tparams"++_DefDefn_paramss = Core.Name "paramss"++_DefDefn_decltpe = Core.Name "decltpe"++_DefDefn_body = Core.Name "body"++data TypeDefn =+ TypeDefn {+ typeDefnMods :: [Mod],+ typeDefnName :: NameType,+ typeDefnTparams :: [ParamType],+ typeDefnBody :: Type}+ deriving (Eq, Ord, Read, Show)++_TypeDefn = Core.Name "hydra.scala.syntax.TypeDefn"++_TypeDefn_mods = Core.Name "mods"++_TypeDefn_name = Core.Name "name"++_TypeDefn_tparams = Core.Name "tparams"++_TypeDefn_body = Core.Name "body"++data ClassDefn =+ ClassDefn {+ classDefnMods :: [Mod],+ classDefnName :: NameType,+ classDefnTparams :: [ParamType],+ classDefnCtor :: PrimaryCtor,+ classDefnTemplate :: Template}+ deriving (Eq, Ord, Read, Show)++_ClassDefn = Core.Name "hydra.scala.syntax.ClassDefn"++_ClassDefn_mods = Core.Name "mods"++_ClassDefn_name = Core.Name "name"++_ClassDefn_tparams = Core.Name "tparams"++_ClassDefn_ctor = Core.Name "ctor"++_ClassDefn_template = Core.Name "template"++data TraitDefn =+ TraitDefn {+ traitDefnMods :: [Mod],+ traitDefnName :: NameType,+ traitDefnTparams :: [ParamType],+ traitDefnCtor :: PrimaryCtor,+ traitDefnTemplate :: Template}+ deriving (Eq, Ord, Read, Show)++_TraitDefn = Core.Name "hydra.scala.syntax.TraitDefn"++_TraitDefn_mods = Core.Name "mods"++_TraitDefn_name = Core.Name "name"++_TraitDefn_tparams = Core.Name "tparams"++_TraitDefn_ctor = Core.Name "ctor"++_TraitDefn_template = Core.Name "template"++data ObjectDefn =+ ObjectDefn {+ objectDefnName :: NameData}+ deriving (Eq, Ord, Read, Show)++_ObjectDefn = Core.Name "hydra.scala.syntax.ObjectDefn"++_ObjectDefn_name = Core.Name "name"++data Pkg =+ Pkg {+ pkgName :: NameData,+ pkgRef :: RefData,+ pkgStats :: [Stat]}+ deriving (Eq, Ord, Read, Show)++_Pkg = Core.Name "hydra.scala.syntax.Pkg"++_Pkg_name = Core.Name "name"++_Pkg_ref = Core.Name "ref"++_Pkg_stats = Core.Name "stats"++data ObjectPkg =+ ObjectPkg {+ objectPkgMods :: [Mod],+ objectPkgName :: NameData,+ objectPkgTemplate :: Template}+ deriving (Eq, Ord, Read, Show)++_ObjectPkg = Core.Name "hydra.scala.syntax.ObjectPkg"++_ObjectPkg_mods = Core.Name "mods"++_ObjectPkg_name = Core.Name "name"++_ObjectPkg_template = Core.Name "template"++data Ctor =+ CtorPrimary PrimaryCtor |+ CtorSecondary SecondaryCtor+ deriving (Eq, Ord, Read, Show)++_Ctor = Core.Name "hydra.scala.syntax.Ctor"++_Ctor_primary = Core.Name "primary"++_Ctor_secondary = Core.Name "secondary"++data PrimaryCtor =+ PrimaryCtor {+ primaryCtorMods :: [Mod],+ primaryCtorName :: Name,+ primaryCtorParamss :: [[ParamData]]}+ deriving (Eq, Ord, Read, Show)++_PrimaryCtor = Core.Name "hydra.scala.syntax.PrimaryCtor"++_PrimaryCtor_mods = Core.Name "mods"++_PrimaryCtor_name = Core.Name "name"++_PrimaryCtor_paramss = Core.Name "paramss"++data SecondaryCtor =+ SecondaryCtor {+ secondaryCtorMods :: [Mod],+ secondaryCtorName :: Name,+ secondaryCtorParamss :: [[ParamData]],+ secondaryCtorInit :: Init,+ secondaryCtorStats :: [Stat]}+ deriving (Eq, Ord, Read, Show)++_SecondaryCtor = Core.Name "hydra.scala.syntax.SecondaryCtor"++_SecondaryCtor_mods = Core.Name "mods"++_SecondaryCtor_name = Core.Name "name"++_SecondaryCtor_paramss = Core.Name "paramss"++_SecondaryCtor_init = Core.Name "init"++_SecondaryCtor_stats = Core.Name "stats"++data Init =+ Init {+ initTpe :: Type,+ initName :: Name,+ initArgss :: [[Data]]}+ deriving (Eq, Ord, Read, Show)++_Init = Core.Name "hydra.scala.syntax.Init"++_Init_tpe = Core.Name "tpe"++_Init_name = Core.Name "name"++_Init_argss = Core.Name "argss"++newtype Self =+ Self {+ unSelf :: ()}+ deriving (Eq, Ord, Read, Show)++_Self = Core.Name "hydra.scala.syntax.Self"++data Template =+ Template {+ templateEarly :: [Stat],+ templateInits :: [Init],+ templateSelf :: Self,+ templateStats :: [Stat]}+ deriving (Eq, Ord, Read, Show)++_Template = Core.Name "hydra.scala.syntax.Template"++_Template_early = Core.Name "early"++_Template_inits = Core.Name "inits"++_Template_self = Core.Name "self"++_Template_stats = Core.Name "stats"++data Mod =+ ModAnnot AnnotMod |+ ModPrivate PrivateMod |+ ModProtected ProtectedMod |+ ModImplicit |+ ModFinal |+ ModSealed |+ ModOpen |+ ModSuper |+ ModOverride |+ ModCase |+ ModAbstract |+ ModCovariant |+ ModContravariant |+ ModLazy |+ ModValParam |+ ModVarParam |+ ModInfix |+ ModInline |+ ModUsing |+ ModOpaque |+ ModTransparent+ deriving (Eq, Ord, Read, Show)++_Mod = Core.Name "hydra.scala.syntax.Mod"++_Mod_annot = Core.Name "annot"++_Mod_private = Core.Name "private"++_Mod_protected = Core.Name "protected"++_Mod_implicit = Core.Name "implicit"++_Mod_final = Core.Name "final"++_Mod_sealed = Core.Name "sealed"++_Mod_open = Core.Name "open"++_Mod_super = Core.Name "super"++_Mod_override = Core.Name "override"++_Mod_case = Core.Name "case"++_Mod_abstract = Core.Name "abstract"++_Mod_covariant = Core.Name "covariant"++_Mod_contravariant = Core.Name "contravariant"++_Mod_lazy = Core.Name "lazy"++_Mod_valParam = Core.Name "valParam"++_Mod_varParam = Core.Name "varParam"++_Mod_infix = Core.Name "infix"++_Mod_inline = Core.Name "inline"++_Mod_using = Core.Name "using"++_Mod_opaque = Core.Name "opaque"++_Mod_transparent = Core.Name "transparent"++data AnnotMod =+ AnnotMod {+ annotModInit :: Init}+ deriving (Eq, Ord, Read, Show)++_AnnotMod = Core.Name "hydra.scala.syntax.AnnotMod"++_AnnotMod_init = Core.Name "init"++data PrivateMod =+ PrivateMod {+ privateModWithin :: Ref}+ deriving (Eq, Ord, Read, Show)++_PrivateMod = Core.Name "hydra.scala.syntax.PrivateMod"++_PrivateMod_within = Core.Name "within"++data ProtectedMod =+ ProtectedMod {+ protectedModWithin :: Ref}+ deriving (Eq, Ord, Read, Show)++_ProtectedMod = Core.Name "hydra.scala.syntax.ProtectedMod"++_ProtectedMod_within = Core.Name "within"++data Enumerator =+ EnumeratorGenerator GeneratorEnumerator |+ EnumeratorCaseGenerator CaseGeneratorEnumerator |+ EnumeratorVal ValEnumerator |+ EnumeratorGuard GuardEnumerator+ deriving (Eq, Ord, Read, Show)++_Enumerator = Core.Name "hydra.scala.syntax.Enumerator"++_Enumerator_generator = Core.Name "generator"++_Enumerator_caseGenerator = Core.Name "caseGenerator"++_Enumerator_val = Core.Name "val"++_Enumerator_guard = Core.Name "guard"++data GeneratorEnumerator =+ GeneratorEnumerator {+ generatorEnumeratorPat :: Pat,+ generatorEnumeratorRhs :: Data}+ deriving (Eq, Ord, Read, Show)++_GeneratorEnumerator = Core.Name "hydra.scala.syntax.GeneratorEnumerator"++_GeneratorEnumerator_pat = Core.Name "pat"++_GeneratorEnumerator_rhs = Core.Name "rhs"++data CaseGeneratorEnumerator =+ CaseGeneratorEnumerator {+ caseGeneratorEnumeratorPat :: Pat,+ caseGeneratorEnumeratorRhs :: Data}+ deriving (Eq, Ord, Read, Show)++_CaseGeneratorEnumerator = Core.Name "hydra.scala.syntax.CaseGeneratorEnumerator"++_CaseGeneratorEnumerator_pat = Core.Name "pat"++_CaseGeneratorEnumerator_rhs = Core.Name "rhs"++data ValEnumerator =+ ValEnumerator {+ valEnumeratorPat :: Pat,+ valEnumeratorRhs :: Data}+ deriving (Eq, Ord, Read, Show)++_ValEnumerator = Core.Name "hydra.scala.syntax.ValEnumerator"++_ValEnumerator_pat = Core.Name "pat"++_ValEnumerator_rhs = Core.Name "rhs"++data GuardEnumerator =+ GuardEnumerator {+ guardEnumeratorCond :: Data}+ deriving (Eq, Ord, Read, Show)++_GuardEnumerator = Core.Name "hydra.scala.syntax.GuardEnumerator"++_GuardEnumerator_cond = Core.Name "cond"++data ImportExportStat =+ ImportExportStatImport Import |+ ImportExportStatExport Export+ deriving (Eq, Ord, Read, Show)++_ImportExportStat = Core.Name "hydra.scala.syntax.ImportExportStat"++_ImportExportStat_import = Core.Name "import"++_ImportExportStat_export = Core.Name "export"++data Import =+ Import {+ importImporters :: [Importer]}+ deriving (Eq, Ord, Read, Show)++_Import = Core.Name "hydra.scala.syntax.Import"++_Import_importers = Core.Name "importers"++data Export =+ Export {+ exportImporters :: [Importer]}+ deriving (Eq, Ord, Read, Show)++_Export = Core.Name "hydra.scala.syntax.Export"++_Export_importers = Core.Name "importers"++data Importer =+ Importer {+ importerRef :: RefData,+ importerImportees :: [Importee]}+ deriving (Eq, Ord, Read, Show)++_Importer = Core.Name "hydra.scala.syntax.Importer"++_Importer_ref = Core.Name "ref"++_Importer_importees = Core.Name "importees"++data Importee =+ ImporteeWildcard |+ ImporteeGiven GivenImportee |+ ImporteeGivenAll |+ ImporteeName NameImportee |+ ImporteeRename RenameImportee |+ ImporteeUnimport UnimportImportee+ deriving (Eq, Ord, Read, Show)++_Importee = Core.Name "hydra.scala.syntax.Importee"++_Importee_wildcard = Core.Name "wildcard"++_Importee_given = Core.Name "given"++_Importee_givenAll = Core.Name "givenAll"++_Importee_name = Core.Name "name"++_Importee_rename = Core.Name "rename"++_Importee_unimport = Core.Name "unimport"++data GivenImportee =+ GivenImportee {+ givenImporteeTpe :: Type}+ deriving (Eq, Ord, Read, Show)++_GivenImportee = Core.Name "hydra.scala.syntax.GivenImportee"++_GivenImportee_tpe = Core.Name "tpe"++data NameImportee =+ NameImportee {+ nameImporteeName :: Name}+ deriving (Eq, Ord, Read, Show)++_NameImportee = Core.Name "hydra.scala.syntax.NameImportee"++_NameImportee_name = Core.Name "name"++data RenameImportee =+ RenameImportee {+ renameImporteeName :: Name,+ renameImporteeRename :: Name}+ deriving (Eq, Ord, Read, Show)++_RenameImportee = Core.Name "hydra.scala.syntax.RenameImportee"++_RenameImportee_name = Core.Name "name"++_RenameImportee_rename = Core.Name "rename"++data UnimportImportee =+ UnimportImportee {+ unimportImporteeName :: Name}+ deriving (Eq, Ord, Read, Show)++_UnimportImportee = Core.Name "hydra.scala.syntax.UnimportImportee"++_UnimportImportee_name = Core.Name "name"++data CaseTree =+ CaseTreeCase Case |+ CaseTreeTypeCase TypeCase+ deriving (Eq, Ord, Read, Show)++_CaseTree = Core.Name "hydra.scala.syntax.CaseTree"++_CaseTree_case = Core.Name "case"++_CaseTree_typeCase = Core.Name "typeCase"++data Case =+ Case {+ casePat :: Pat,+ caseCond :: (Maybe Data),+ caseBody :: Data}+ deriving (Eq, Ord, Read, Show)++_Case = Core.Name "hydra.scala.syntax.Case"++_Case_pat = Core.Name "pat"++_Case_cond = Core.Name "cond"++_Case_body = Core.Name "body"++data TypeCase =+ TypeCase {+ typeCasePat :: Type,+ typeCaseBody :: Type}+ deriving (Eq, Ord, Read, Show)++_TypeCase = Core.Name "hydra.scala.syntax.TypeCase"++_TypeCase_pat = Core.Name "pat"++_TypeCase_body = Core.Name "body"++data Source =+ Source {+ sourceStats :: [Stat]}+ deriving (Eq, Ord, Read, Show)++_Source = Core.Name "hydra.scala.syntax.Source"++_Source_stats = Core.Name "stats"
+ src/main/haskell/Hydra/Scala/Utils.hs view
@@ -0,0 +1,232 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Utility functions for constructing Scala AST nodes++module Hydra.Scala.Utils where++import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.File as ErrorFile+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Error.System as ErrorSystem+import qualified Hydra.Errors as Errors+import qualified Hydra.File as File+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Overlay.Haskell.Lib.Math as Math+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scala.Language as Language+import qualified Hydra.Scala.Syntax as Syntax+import qualified Hydra.Strip as Strip+import qualified Hydra.System as System+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Time as Time+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S++-- | Extract the name from a type, if it is a named type+nameOfType :: t0 -> Core.Type -> Maybe Core.Name+nameOfType cx t =+ case (Strip.deannotateType t) of+ Core.TypeVariable v0 -> Just v0+ Core.TypeForall v0 -> nameOfType cx (Core.forallTypeBody v0)+ _ -> Nothing++-- | Qualify a union field name, optionally prefixing with the Scala type name+qualifyUnionFieldName :: String -> Maybe Core.Name -> Core.Name -> String+qualifyUnionFieldName dlft sname fname =+ Strings.cat2 (Optionals.cases sname dlft (\n -> Strings.cat2 (scalaTypeName True n) ".")) (scalaEscapeName (Core.unName fname))++-- | Apply a Scala data expression to a list of arguments+sapply :: Syntax.Data -> [Syntax.Data] -> Syntax.Data+sapply fun args =+ Syntax.DataApply (Syntax.ApplyData {+ Syntax.applyDataFun = fun,+ Syntax.applyDataArgs = args})++-- | Apply explicit type parameters to a Scala expression (e.g. f[A, B])+sapplyTypes :: Syntax.Data -> [Syntax.Type] -> Syntax.Data+sapplyTypes fun typeArgs =++ let typeToStr = \t -> typeToString t+ typeStrings = Lists.map typeToStr typeArgs+ typeArgStr =+ Strings.cat [+ "[",+ (Strings.intercalate ", " typeStrings),+ "]"]+ in case fun of+ Syntax.DataRef v0 -> case v0 of+ Syntax.RefDataName v1 ->+ let nameStr = Syntax.nameDataValue v1+ rawName = Syntax.unPredefString nameStr+ in (sname (Strings.cat2 rawName typeArgStr))+ Syntax.RefDataSelect v1 ->+ let qual = Syntax.selectDataQual v1+ selName = Syntax.selectDataName v1+ nameStr = Syntax.nameDataValue selName+ rawName = Syntax.unPredefString nameStr+ in (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {+ Syntax.selectDataQual = qual,+ Syntax.selectDataName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString (Strings.cat2 rawName typeArgStr))}})))+ _ -> fun+ _ -> fun++-- | Create a Scala assignment expression+sassign :: Syntax.Data -> Syntax.Data -> Syntax.Data+sassign lhs rhs =+ Syntax.DataAssign (Syntax.AssignData {+ Syntax.assignDataLhs = lhs,+ Syntax.assignDataRhs = rhs})++-- | Like scalaEscapeName, but also renames 'values' to 'values_' to avoid conflict with Scala 3 enum's synthesized values() method+scalaEscapeEnumCaseName :: String -> String+scalaEscapeEnumCaseName s =++ let renamed = Logic.ifElse (Equality.equal s "values") "values_" s+ in (scalaEscapeName renamed)++-- | Sanitize a name for Scala: escape reserved words, replace invalid characters+scalaEscapeName :: String -> String+scalaEscapeName s =++ let sanitized = Strings.fromList (Lists.map (\c -> Logic.ifElse (Equality.equal c 39) 95 c) (Strings.toList s))+ sanitized2 = Logic.ifElse (Equality.equal sanitized "_") "_x" sanitized+ sanitized3 = Logic.ifElse (Equality.equal sanitized2 "toString") "toString_" sanitized2+ needsBackticks =+ Logic.or (Sets.member sanitized3 scalaReservedWords) (Logic.and (Equality.gt (Strings.length sanitized3) 0) (Equality.equal (Optionals.fromOptional 0 (Strings.maybeCharAt (Math.sub (Strings.length sanitized3) 1) sanitized3)) 95))+ in (Logic.ifElse needsBackticks (Strings.cat [+ "`",+ sanitized3,+ "`"]) sanitized3)++-- | Reference to scalaReservedWords from the language module+scalaReservedWords :: S.Set String+scalaReservedWords = Language.scalaReservedWords++-- | Convert a Hydra name to a Scala type name+scalaTypeName :: Bool -> Core.Name -> String+scalaTypeName qualify name =+ Logic.ifElse (Logic.or qualify (Sets.member (Names.localNameOf name) scalaReservedWords)) (Core.unName name) (Names.localNameOf name)++-- | Create a Scala lambda (function) expression+slambda :: String -> Syntax.Data -> Maybe Syntax.Type -> Syntax.Data+slambda v body sdom =+ Syntax.DataFunction (Syntax.FunctionData {+ Syntax.functionDataParams = [+ Syntax.ParamData {+ Syntax.paramDataMods = [],+ Syntax.paramDataName = (Syntax.NameValue v),+ Syntax.paramDataDecltpe = sdom,+ Syntax.paramDataDefault = Nothing}],+ Syntax.functionDataBody = body})++-- | Create a Scala name reference+sname :: String -> Syntax.Data+sname s = Syntax.DataRef (Syntax.RefDataName (Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString s)}))++-- | Create a Scala primitive reference from a Hydra name+sprim :: Core.Name -> Syntax.Data+sprim name =++ let qname = Names.qualifyName name+ prefix = Packaging.unModuleName (Optionals.fromOptional (Packaging.ModuleName "") (Util.qualifiedNameModuleName qname))+ local = scalaEscapeName (Util.qualifiedNameLocal qname)+ in (sname (Strings.cat2 (Strings.cat2 prefix ".") local))++-- | Apply a Scala type to a list of type arguments+stapply :: Syntax.Type -> [Syntax.Type] -> Syntax.Type+stapply t args =+ Syntax.TypeApply (Syntax.ApplyType {+ Syntax.applyTypeTpe = t,+ Syntax.applyTypeArgs = args})++-- | Apply a Scala type to one type argument+stapply1 :: Syntax.Type -> Syntax.Type -> Syntax.Type+stapply1 t1 t2 = stapply t1 [+ t2]++-- | Apply a Scala type to two type arguments+stapply2 :: Syntax.Type -> Syntax.Type -> Syntax.Type -> Syntax.Type+stapply2 t1 t2 t3 =+ stapply t1 [+ t2,+ t3]++-- | Create a Scala type parameter from a Hydra name, capitalizing to avoid collision with value params+stparam :: Core.Name -> Syntax.ParamType+stparam name =++ let v = Formatting.capitalize (Core.unName name)+ in Syntax.ParamType {+ Syntax.paramTypeMods = [],+ Syntax.paramTypeName = (Syntax.NameValue v),+ Syntax.paramTypeTparams = [],+ Syntax.paramTypeTbounds = [],+ Syntax.paramTypeVbounds = [],+ Syntax.paramTypeCbounds = []}++-- | Create a Scala type reference by name+stref :: String -> Syntax.Type+stref s = Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+ Syntax.nameTypeValue = s}))++-- | Create a Scala pattern variable+svar :: Core.Name -> Syntax.Pat+svar name =++ let v = Core.unName name+ in (Syntax.PatVar (Syntax.VarPat {+ Syntax.varPatName = Syntax.NameData {+ Syntax.nameDataValue = (Syntax.PredefString v)}}))++-- | Convert a Scala type to its string representation+typeToString :: Syntax.Type -> String+typeToString t =+ case t of+ Syntax.TypeRef v0 -> case v0 of+ Syntax.RefTypeName v1 -> Syntax.nameTypeValue v1+ _ -> "Any"+ Syntax.TypeVar v0 -> Syntax.nameTypeValue (Syntax.varTypeName v0)+ Syntax.TypeFunction v0 ->+ let params = Lists.map typeToString (Syntax.functionTypeParams v0)+ res = typeToString (Syntax.functionTypeRes v0)+ in (Strings.cat [+ "(",+ (Strings.intercalate ", " params),+ ") => ",+ res])+ Syntax.TypeApply v0 ->+ let base = typeToString (Syntax.applyTypeTpe v0)+ argStrs = Lists.map typeToString (Syntax.applyTypeArgs v0)+ in (Strings.cat [+ base,+ "[",+ (Strings.intercalate ", " argStrs),+ "]"])+ _ -> "Any"