hydra-python 0.17.0 → 0.17.1

raw patch · 8 files changed

+1774/−13 lines, 8 filesdep ~hydra-kernelPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: hydra-kernel

API changes (from Hackage documentation)

Files

• CHANGELOG.md +139/−0
• hydra-python.cabal +6/−3
• src/main/haskell/Hydra/Dsl/Python/Environment.hs +16/−0
• src/main/haskell/Hydra/Dsl/Python/Names.hs +211/−0
• src/main/haskell/Hydra/Dsl/Python/Syntax.hs +797/−0
• src/main/haskell/Hydra/Dsl/Python/Utils.hs +576/−0
• src/main/haskell/Hydra/Python/Coder.hs +10/−10
• src/main/haskell/Hydra/Python/Pyproject.hs +19/−0

@@ -15,6 +15,145 @@  --- +## [0.17.1] - unreleased++Development version. Opens the 0.17.x line — the first release built entirely against+published 0.17.0 hosts (Hackage / PyPI / Maven Central), with the `hostOverrides` shims+that were needed while 0.16.1 lacked the effect type and I/O primitives removed.++### New features++- **Generated term-reference DSLs** ([#467](https://github.com/CategoricalData/hydra/issues/467)):+  kernel *term* modules now project generated DSL surfaces, completing the story begun with+  type-module DSLs and the generated primitive wrappers (`hydra.dsl.lib.*`, 0.17.0). A+  signature read-back in the DSL pass reuses the main pass's inference, and a demand-curated+  set of 19 kernel term modules (plus the json/test/extract modules) emits one typed,+  rename-safe reference per definition into every target language — e.g. Haskell+  `Hydra.Dsl.Strip.deannotateType`, Java `hydra.dsl.Strip.deannotateType(...)`, Python+  `hydra.dsl.strip.deannotate_type(...)`. The Java and Python coder sources were pivoted onto+  the generated references, retiring ~700 stringly-typed inline `var("hydra....")` references+  and shrinking Python's hand registry to the non-generatable remainder (byte-identical+  generated output before and after). Follow-ups:+  [#555](https://github.com/CategoricalData/hydra/issues/555) (typed references to derived+  encode/decode/show functions via `TypedName`),+  [#556](https://github.com/CategoricalData/hydra/issues/556) (non-kernel packages).+- **Package validation** ([#574](https://github.com/CategoricalData/hydra/issues/574),+  [#575](https://github.com/CategoricalData/hydra/issues/575)): a translingual `hydra.validate.*`+  framework carries per-package `ValidationProfile`s (error/warning rules, error/warning caps) and a+  catalog of checks — undeclared-package-dependency detection (now a fatal gate, #574),+  definition-name convention (PascalCase), definition ordering, documentation completeness, and+  conflicting-variant-name detection — layered on the existing core term/type well-formedness rules.+  A kernel-strict / others-relaxed policy keeps `/sync` green fleet-wide while the documentation+  backlog drains. See the new [Validation](https://github.com/CategoricalData/hydra/wiki/Validation)+  wiki page for the full per-package constraint specification.+- **DSL-authoring registration guards** ([#554](https://github.com/CategoricalData/hydra/issues/554)):+  fail-fast authoring-time validation for the host-native DSL sources — every DSL-authoring module in+  Java/`hydra-jvm`, Python, and Scala now asserts its definitions are fully registered+  (`Defs.checkComplete` / `check_complete`), backed by a Haskell kernel-source registration-completeness+  scanner, so a definition added to a source file but omitted from its `definitions` list fails loudly+  instead of silently vanishing from the generated output.+- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546),+  [#529](https://github.com/CategoricalData/hydra/issues/529),+  [#530](https://github.com/CategoricalData/hydra/issues/530)): the build-orchestration logic that had+  lived only in host scripts is now translingual Hydra. Pure module-list utilities became+  `hydra.build.modules` (#529) and the orphan-reconcile decision became `hydra.build.reconcile` (#530),+  each with a translingual test suite; the `hydra.build.*` modules were then extracted into a dedicated+  `hydra-build` package (#546), separate from the kernel.+- **Metadata sidecar + content/version-addressed freshness**+  ([#415](https://github.com/CategoricalData/hydra/issues/415)): dist manifests now carry a+  `moduleFormatVersion` field, and the generator's freshness basis is content/version-addressed — the+  groundwork for reproducible, cache-correct incremental generation.+- **Structured generation-provenance record**+  ([#523](https://github.com/CategoricalData/hydra/issues/523)): each generation run now records a+  structured `Generation` provenance entry (digest v2), replacing the ad-hoc shell threading of+  generation metadata.+- **Worker + issue hierarchy** ([#557](https://github.com/CategoricalData/hydra/issues/557)): a+  principled agent/worker framework — roles and parentage mirroring the GitHub issue tree, a+  cross-worktree message transport with a verify-after-copy protocol, a blocking-aware design-question+  (`decisions/`) channel, an issue-proposal queue with the `/issues` command, an autonomy-dial banner,+  and cross-machine staging coordination. Contributor-facing process only; no change to generated code.++### API and usability++- **DSL usability passes** ([#430](https://github.com/CategoricalData/hydra/issues/430),+  [#553](https://github.com/CategoricalData/hydra/issues/553)): reviewed the host-native Java, Python,+  and Scala DSL surfaces for ergonomics and cross-host parity (documented def shapes, added a Scala+  projection helper), bringing the three authoring dialects into closer alignment.++### Fixed++Bug fixes landed this cycle, grouped by area (see each issue for detail):++- **TypeScript** — reactivated `hydra.lib.*` primitive tests surfaced encoder gaps: lazy show-calling+  let bindings and compact bare-string `LiteralType` expansion in the test converter+  ([#564](https://github.com/CategoricalData/hydra/issues/564)),+  `binaryToBytes` registration + base64 binary decode in `decodeUtf8`+  ([#561](https://github.com/CategoricalData/hydra/issues/561)),+  `hydra.test.build.*` emission after the #546 split+  ([#570](https://github.com/CategoricalData/hydra/issues/570)), and `HYDRA_DEFAULT_IMPLS` support in+  the test runner ([#536](https://github.com/CategoricalData/hydra/issues/536)).+- **Tests and CI** — restored the default-primitive-implementation testing solution+  ([#388](https://github.com/CategoricalData/hydra/issues/388),+  [#549](https://github.com/CategoricalData/hydra/issues/549)), reactivated previously-ignored kernel+  test cases ([#513](https://github.com/CategoricalData/hydra/issues/513),+  [#550](https://github.com/CategoricalData/hydra/issues/550)), wired the regression harnesses into CI+  and split them out of the monolithic Haskell job for timeout headroom+  ([#535](https://github.com/CategoricalData/hydra/issues/535),+  [#563](https://github.com/CategoricalData/hydra/issues/563)), added Scala/Go/Lisp+  self-containment gates to `verify-distribution.sh`+  ([#537](https://github.com/CategoricalData/hydra/issues/537)), a manifest-JSON-tracked CI check+  ([#541](https://github.com/CategoricalData/hydra/issues/541)), a per-package test-digest freshness+  fix ([#551](https://github.com/CategoricalData/hydra/issues/551)), overlay-file restoration in+  `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)), and a+  sync-freshness fingerprint that now sees host-native DSL sources+  ([#562](https://github.com/CategoricalData/hydra/issues/562)).+- **Kernel and coders** — Java binary-literal signed-byte emission+  ([#528](https://github.com/CategoricalData/hydra/issues/528)), `hydra.json.Decode.fromJson`+  parametric-type (Application/Forall) support+  ([#531](https://github.com/CategoricalData/hydra/issues/531)), stale 2-param `Coder` shape in+  Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552)), and a+  kernel dead-code/TODO cleanup ([#538](https://github.com/CategoricalData/hydra/issues/538)).+- **Lib and build** — `hydra.lib.files` copy/removeDirectory/status overlays across all nine hosts+  ([#525](https://github.com/CategoricalData/hydra/issues/525)), `hydra.build.*` regeneration into the+  Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)), Scheme maps+  last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)),+  standalone-kernel SHA dependency ([#542](https://github.com/CategoricalData/hydra/issues/542)),+  the lexicon's empty Types section ([#539](https://github.com/CategoricalData/hydra/issues/539)), and+  a duplicated generated-file header in `generate-head-haskell-build.py`+  ([#540](https://github.com/CategoricalData/hydra/issues/540)).++- **TypeScript overlay-import rewrite** ([#565](https://github.com/CategoricalData/hydra/issues/565)):+  the TypeScript coder's lib overlay-import rewrite no longer captures `hydra.lib.defaults`, which is a+  generated (not overlaid) module; excluding it fixes spurious import references in generated TypeScript.++- **Lexicon generation** (`bin/regenerate-lexicon.sh`): the generator had been failing+  silently since the encoder/decoder modules moved to in-memory synthesis+  ([#448](https://github.com/CategoricalData/hydra/issues/448)) — the script masked the+  failure and left a stale `docs/hydra-lexicon.txt` missing the four effectful primitive+  libraries (`hydra.lib.{effects,files,system,text}`). The synthesized coder modules are+  now included in the lexicon universe, the script fails loudly, and the regenerated+  lexicon covers all 267 primitives across 17 library modules.+- **`bin/prepare-release.sh`**: the non-blocking Java quality check invoked Gradle+  subprojects (`:hydra-rdf4j:test` etc.) that were removed in+  [#511](https://github.com/CategoricalData/hydra/issues/511), so it always warned without+  checking anything; it now runs the `dist/java/hydra-pg` package tests (the current home+  of the former binding tests).+- **`.gitignore`**: the ignore rules for the overlaid hand-written Haskell runtime still+  named pre-[#501](https://github.com/CategoricalData/hydra/issues/501) paths, so 41+  duplicate copies under `dist/haskell/` had become tracked; the rules now match the+  `Hydra/Overlay/` location and the duplicates are untracked.++### Documentation++- Corrected the 0.17.0 Maven coordinates throughout (Java artifacts publish under group+  `net.fortytwo.hydra.java`, Scala under `net.fortytwo.hydra.scala`,+  [#519](https://github.com/CategoricalData/hydra/issues/519)); added the npm and Scala+  release channels to the README; added TypeScript/Scala/Lisp sections to Getting started;+  repointed stale pre-#418/#501 DSL paths in the architecture docs; added GitHub issue and+  PR templates.++---+ ## [0.17.0] - 2026-07-01  Major themes: first-class support for effects and I/O in the kernel, TypeScript and

@@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.39.1.+-- This file has been generated from package.yaml by hpack version 0.38.1. -- -- see: https://github.com/sol/hpack  name:           hydra-python-version:        0.17.0+version:        0.17.1 synopsis:       Hydra's Python coder: emit Python source from Hydra modules description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". Python support for Hydra category:       Data@@ -28,11 +28,14 @@ library   exposed-modules:       Hydra.Dsl.Python.Environment+      Hydra.Dsl.Python.Names       Hydra.Dsl.Python.Syntax+      Hydra.Dsl.Python.Utils       Hydra.Python.Coder       Hydra.Python.Environment       Hydra.Python.Language       Hydra.Python.Names+      Hydra.Python.Pyproject       Hydra.Python.Serde       Hydra.Python.Syntax       Hydra.Python.Testing@@ -44,6 +47,6 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-kernel ==0.17.0+    , hydra-kernel ==0.17.1     , scientific >=0.3.7 && <0.4   default-language: Haskell2010

@@ -54,6 +54,10 @@         Core.projectionFieldName = (Core.Name "metadata")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.environment.PyGraph+pyGraphPyGraph :: Typed.TypedName Environment.PyGraph+pyGraphPyGraph = Typed.TypedName (Core.Name "hydra.python.environment.PyGraph")+ -- | DSL updater for the graph field of hydra.python.environment.PyGraph pyGraphWithGraph :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.PyGraph pyGraphWithGraph original newVal =@@ -161,6 +165,10 @@         Core.projectionFieldName = (Core.Name "nullaryBindings")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.environment.PythonEnvironment+pythonEnvironmentPythonEnvironment :: Typed.TypedName Environment.PythonEnvironment+pythonEnvironmentPythonEnvironment = Typed.TypedName (Core.Name "hydra.python.environment.PythonEnvironment")+ -- | DSL accessor for the skipCasts field of hydra.python.environment.PythonEnvironment pythonEnvironmentSkipCasts :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Bool pythonEnvironmentSkipCasts x =@@ -628,6 +636,10 @@         Core.projectionFieldName = (Core.Name "namespaces")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.environment.PythonModuleMetadata+pythonModuleMetadataPythonModuleMetadata :: Typed.TypedName Environment.PythonModuleMetadata+pythonModuleMetadataPythonModuleMetadata = Typed.TypedName (Core.Name "hydra.python.environment.PythonModuleMetadata")+ -- | DSL accessor for the typeVariables field of hydra.python.environment.PythonModuleMetadata pythonModuleMetadataTypeVariables :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (S.Set Core.Name) pythonModuleMetadataTypeVariables x =@@ -4615,3 +4627,7 @@       Core.injectionField = Core.Field {         Core.fieldName = (Core.Name "python312"),         Core.fieldTerm = Core.TermUnit}}))++-- | DSL name token for hydra.python.environment.PythonVersion+pythonVersionPythonVersion :: Typed.TypedName Environment.PythonVersion+pythonVersionPythonVersion = Typed.TypedName (Core.Name "hydra.python.environment.PythonVersion")

@@ -0,0 +1,211 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.python.names++module Hydra.Dsl.Python.Names where++import qualified Hydra.Ast as Ast+import qualified Hydra.Classes as Classes+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Error.Checking as ErrorChecking+import qualified Hydra.Dsl.Error.Core as DslErrorCore+import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging+import qualified Hydra.Dsl.Errors as DslErrors+import qualified Hydra.Dsl.Formatting as DslFormatting+import qualified Hydra.Dsl.Graph as DslGraph+import qualified Hydra.Dsl.Json.Model as JsonModel+import qualified Hydra.Dsl.Names as DslNames+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Dsl.Parsing as DslParsing+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Dsl.Python.Environment as PythonEnvironment+import qualified Hydra.Dsl.Python.Syntax as PythonSyntax+import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Relational as DslRelational+import qualified Hydra.Dsl.Tabular as DslTabular+import qualified Hydra.Dsl.Testing as DslTesting+import qualified Hydra.Dsl.Topology as DslTopology+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Dsl.Validation as DslValidation+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Python.Environment as Environment+import qualified Hydra.Python.Language as Language+import qualified Hydra.Python.Names as PythonNames+import qualified Hydra.Python.Serde as Serde+import qualified Hydra.Python.Syntax as Syntax+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M++-- | DSL reference to hydra.python.names.encodeConstantForFieldName+encodeConstantForFieldName :: Typed.TypedTerm t0 -> Typed.TypedTerm t1 -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Name+encodeConstantForFieldName arg0 arg1 arg2 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeConstantForFieldName")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.python.names.encodeConstantForTypeName+encodeConstantForTypeName :: Typed.TypedTerm t0 -> Typed.TypedTerm t1 -> Typed.TypedTerm Syntax.Name+encodeConstantForTypeName arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeConstantForTypeName")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.names.encodeEnumValue+encodeEnumValue :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Name+encodeEnumValue arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeEnumValue")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.names.encodeFieldName+encodeFieldName :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Name+encodeFieldName arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeFieldName")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.names.encodeName+encodeName :: Typed.TypedTerm Bool -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Name+encodeName arg0 arg1 arg2 arg3 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeName")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.python.names.encodeNameQualified+encodeNameQualified :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Name+encodeNameQualified arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeNameQualified")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.names.encodeNamespace+encodeNamespace :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Syntax.DottedName+encodeNamespace arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeNamespace")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.names.encodeNamespaceStringWithOverrides+encodeNamespaceStringWithOverrides :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm String+encodeNamespaceStringWithOverrides arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeNamespaceStringWithOverrides")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.names.encodeNamespaceWithOverrides+encodeNamespaceWithOverrides :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Syntax.DottedName+encodeNamespaceWithOverrides arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeNamespaceWithOverrides")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.names.encodeTypeVariable+encodeTypeVariable :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Name+encodeTypeVariable arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.encodeTypeVariable")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.names.overlayPythonModuleAliases+overlayPythonModuleAliases :: Typed.TypedTerm (M.Map Packaging.ModuleName String)+overlayPythonModuleAliases = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.python.names.overlayPythonModuleAliases"))++-- | DSL reference to hydra.python.names.sanitizePythonName+sanitizePythonName :: Typed.TypedTerm String -> Typed.TypedTerm String+sanitizePythonName arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.sanitizePythonName")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.names.termVariableReference+termVariableReference :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Expression+termVariableReference arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.termVariableReference")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.names.typeVariableReference+typeVariableReference :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Expression+typeVariableReference arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.typeVariableReference")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.names.useFutureAnnotations+useFutureAnnotations :: Typed.TypedTerm Bool+useFutureAnnotations = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.python.names.useFutureAnnotations"))++-- | DSL reference to hydra.python.names.variableReference+variableReference :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Expression+variableReference arg0 arg1 arg2 arg3 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.variableReference")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.python.names.variantName+variantName :: Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Syntax.Name+variantName arg0 arg1 arg2 arg3 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.names.variantName")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))

@@ -11,6 +11,10 @@ import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL name token for hydra.python.syntax.AnnotatedRhs+annotatedRhsAnnotatedRhs :: Typed.TypedName Syntax.AnnotatedRhs+annotatedRhsAnnotatedRhs = Typed.TypedName (Core.Name "hydra.python.syntax.AnnotatedRhs")+ -- | DSL injection for the star variant of hydra.python.syntax.AnnotatedRhs annotatedRhsStar :: Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm Syntax.AnnotatedRhs annotatedRhsStar x =@@ -42,6 +46,10 @@           Core.fieldName = (Core.Name "statement"),           Core.fieldTerm = (Typed.unTypedTerm statement)}]})) +-- | DSL name token for hydra.python.syntax.AnnotatedStatement+annotatedStatementAnnotatedStatement :: Typed.TypedName Syntax.AnnotatedStatement+annotatedStatementAnnotatedStatement = Typed.TypedName (Core.Name "hydra.python.syntax.AnnotatedStatement")+ -- | DSL accessor for the comment field of hydra.python.syntax.AnnotatedStatement annotatedStatementComment :: Typed.TypedTerm Syntax.AnnotatedStatement -> Typed.TypedTerm String annotatedStatementComment x =@@ -101,6 +109,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Annotation"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Annotation+annotationAnnotation :: Typed.TypedName Syntax.Annotation+annotationAnnotation = Typed.TypedName (Core.Name "hydra.python.syntax.Annotation")+ -- | DSL constructor for hydra.python.syntax.Args args :: Typed.TypedTerm [Syntax.PosArg] -> Typed.TypedTerm [Syntax.KwargOrStarred] -> Typed.TypedTerm [Syntax.KwargOrDoubleStarred] -> Typed.TypedTerm Syntax.Args args positional kwargOrStarred kwargOrDoubleStarred =@@ -117,6 +129,10 @@           Core.fieldName = (Core.Name "kwargOrDoubleStarred"),           Core.fieldTerm = (Typed.unTypedTerm kwargOrDoubleStarred)}]})) +-- | DSL name token for hydra.python.syntax.Args+argsArgs :: Typed.TypedName Syntax.Args+argsArgs = Typed.TypedName (Core.Name "hydra.python.syntax.Args")+ -- | DSL accessor for the kwargOrDoubleStarred field of hydra.python.syntax.Args argsKwargOrDoubleStarred :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm [Syntax.KwargOrDoubleStarred] argsKwargOrDoubleStarred x =@@ -238,6 +254,10 @@         Core.projectionFieldName = (Core.Name "as")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.AsPattern+asPatternAsPattern :: Typed.TypedName Syntax.AsPattern+asPatternAsPattern = Typed.TypedName (Core.Name "hydra.python.syntax.AsPattern")+ -- | DSL accessor for the pattern field of hydra.python.syntax.AsPattern asPatternPattern :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.OrPattern asPatternPattern x =@@ -294,6 +314,10 @@           Core.fieldName = (Core.Name "expression2"),           Core.fieldTerm = (Typed.unTypedTerm expression2)}]})) +-- | DSL name token for hydra.python.syntax.AssertStatement+assertStatementAssertStatement :: Typed.TypedName Syntax.AssertStatement+assertStatementAssertStatement = Typed.TypedName (Core.Name "hydra.python.syntax.AssertStatement")+ -- | DSL accessor for the expression1 field of hydra.python.syntax.AssertStatement assertStatementExpression1 :: Typed.TypedTerm Syntax.AssertStatement -> Typed.TypedTerm Syntax.Expression assertStatementExpression1 x =@@ -346,6 +370,10 @@           Core.fieldName = (Core.Name "expression2"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.python.syntax.Assignment+assignmentAssignment :: Typed.TypedName Syntax.Assignment+assignmentAssignment = Typed.TypedName (Core.Name "hydra.python.syntax.Assignment")+ -- | DSL injection for the aug variant of hydra.python.syntax.Assignment assignmentAug :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.Assignment assignmentAug x =@@ -368,6 +396,10 @@           Core.fieldName = (Core.Name "expression"),           Core.fieldTerm = (Typed.unTypedTerm expression)}]})) +-- | DSL name token for hydra.python.syntax.AssignmentExpression+assignmentExpressionAssignmentExpression :: Typed.TypedName Syntax.AssignmentExpression+assignmentExpressionAssignmentExpression = Typed.TypedName (Core.Name "hydra.python.syntax.AssignmentExpression")+ -- | DSL accessor for the expression field of hydra.python.syntax.AssignmentExpression assignmentExpressionExpression :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Expression assignmentExpressionExpression x =@@ -438,6 +470,10 @@         Core.fieldName = (Core.Name "untyped"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Atom+atomAtom :: Typed.TypedName Syntax.Atom+atomAtom = Typed.TypedName (Core.Name "hydra.python.syntax.Atom")+ -- | DSL injection for the dict variant of hydra.python.syntax.Atom atomDict :: Typed.TypedTerm Syntax.Dict -> Typed.TypedTerm Syntax.Atom atomDict x =@@ -589,6 +625,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Attribute"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Attribute+attributeAttribute :: Typed.TypedName Syntax.Attribute+attributeAttribute = Typed.TypedName (Core.Name "hydra.python.syntax.Attribute")+ -- | DSL injection for the ampersandEqual variant of hydra.python.syntax.AugAssign augAssignAmpersandEqual :: Typed.TypedTerm Syntax.AugAssign augAssignAmpersandEqual =@@ -607,6 +647,10 @@         Core.fieldName = (Core.Name "atEqual"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.AugAssign+augAssignAugAssign :: Typed.TypedName Syntax.AugAssign+augAssignAugAssign = Typed.TypedName (Core.Name "hydra.python.syntax.AugAssign")+ -- | DSL injection for the barEqual variant of hydra.python.syntax.AugAssign augAssignBarEqual :: Typed.TypedTerm Syntax.AugAssign augAssignBarEqual =@@ -722,6 +766,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) +-- | DSL name token for hydra.python.syntax.AugAssignment+augAssignmentAugAssignment :: Typed.TypedName Syntax.AugAssignment+augAssignmentAugAssignment = Typed.TypedName (Core.Name "hydra.python.syntax.AugAssignment")+ -- | DSL accessor for the augassign field of hydra.python.syntax.AugAssignment augAssignmentAugassign :: Typed.TypedTerm Syntax.AugAssignment -> Typed.TypedTerm Syntax.AugAssign augAssignmentAugassign x =@@ -843,6 +891,10 @@         Core.projectionFieldName = (Core.Name "await")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.AwaitPrimary+awaitPrimaryAwaitPrimary :: Typed.TypedName Syntax.AwaitPrimary+awaitPrimaryAwaitPrimary = Typed.TypedName (Core.Name "hydra.python.syntax.AwaitPrimary")+ -- | DSL accessor for the primary field of hydra.python.syntax.AwaitPrimary awaitPrimaryPrimary :: Typed.TypedTerm Syntax.AwaitPrimary -> Typed.TypedTerm Syntax.Primary awaitPrimaryPrimary x =@@ -899,6 +951,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) +-- | DSL name token for hydra.python.syntax.BitwiseAnd+bitwiseAndBitwiseAnd :: Typed.TypedName Syntax.BitwiseAnd+bitwiseAndBitwiseAnd = Typed.TypedName (Core.Name "hydra.python.syntax.BitwiseAnd")+ -- | DSL accessor for the lhs field of hydra.python.syntax.BitwiseAnd bitwiseAndLhs :: Typed.TypedTerm Syntax.BitwiseAnd -> Typed.TypedTerm (Maybe Syntax.BitwiseAnd) bitwiseAndLhs x =@@ -964,6 +1020,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) +-- | DSL name token for hydra.python.syntax.BitwiseOr+bitwiseOrBitwiseOr :: Typed.TypedName Syntax.BitwiseOr+bitwiseOrBitwiseOr = Typed.TypedName (Core.Name "hydra.python.syntax.BitwiseOr")+ -- | DSL accessor for the lhs field of hydra.python.syntax.BitwiseOr bitwiseOrLhs :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm (Maybe Syntax.BitwiseOr) bitwiseOrLhs x =@@ -1029,6 +1089,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) +-- | DSL name token for hydra.python.syntax.BitwiseXor+bitwiseXorBitwiseXor :: Typed.TypedName Syntax.BitwiseXor+bitwiseXorBitwiseXor = Typed.TypedName (Core.Name "hydra.python.syntax.BitwiseXor")+ -- | DSL accessor for the lhs field of hydra.python.syntax.BitwiseXor bitwiseXorLhs :: Typed.TypedTerm Syntax.BitwiseXor -> Typed.TypedTerm (Maybe Syntax.BitwiseXor) bitwiseXorLhs x =@@ -1081,6 +1145,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.python.syntax.Block+blockBlock :: Typed.TypedName Syntax.Block+blockBlock = Typed.TypedName (Core.Name "hydra.python.syntax.Block")+ -- | DSL injection for the indented variant of hydra.python.syntax.Block blockIndented :: Typed.TypedTerm [[Syntax.Statement]] -> Typed.TypedTerm Syntax.Block blockIndented x =@@ -1106,6 +1174,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.CapturePattern"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.CapturePattern+capturePatternCapturePattern :: Typed.TypedName Syntax.CapturePattern+capturePatternCapturePattern = Typed.TypedName (Core.Name "hydra.python.syntax.CapturePattern")+ -- | DSL constructor for hydra.python.syntax.CaseBlock caseBlock :: Typed.TypedTerm Syntax.Patterns -> Typed.TypedTerm (Maybe Syntax.Guard) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CaseBlock caseBlock patterns guard body =@@ -1131,6 +1203,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.CaseBlock+caseBlockCaseBlock :: Typed.TypedName Syntax.CaseBlock+caseBlockCaseBlock = Typed.TypedName (Core.Name "hydra.python.syntax.CaseBlock")+ -- | DSL accessor for the guard field of hydra.python.syntax.CaseBlock caseBlockGuard :: Typed.TypedTerm Syntax.CaseBlock -> Typed.TypedTerm (Maybe Syntax.Guard) caseBlockGuard x =@@ -1261,6 +1337,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ClassDefinition+classDefinitionClassDefinition :: Typed.TypedName Syntax.ClassDefinition+classDefinitionClassDefinition = Typed.TypedName (Core.Name "hydra.python.syntax.ClassDefinition")+ -- | DSL accessor for the decorators field of hydra.python.syntax.ClassDefinition classDefinitionDecorators :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm (Maybe Syntax.Decorators) classDefinitionDecorators x =@@ -1494,6 +1574,10 @@           Core.fieldName = (Core.Name "keywordPatterns"),           Core.fieldTerm = (Typed.unTypedTerm keywordPatterns)}]})) +-- | DSL name token for hydra.python.syntax.ClassPattern+classPatternClassPattern :: Typed.TypedName Syntax.ClassPattern+classPatternClassPattern = Typed.TypedName (Core.Name "hydra.python.syntax.ClassPattern")+ -- | DSL accessor for the keywordPatterns field of hydra.python.syntax.ClassPattern classPatternKeywordPatterns :: Typed.TypedTerm Syntax.ClassPattern -> Typed.TypedTerm (Maybe Syntax.KeywordPatterns) classPatternKeywordPatterns x =@@ -1611,6 +1695,10 @@         Core.fieldName = (Core.Name "class"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.ClosedPattern+closedPatternClosedPattern :: Typed.TypedName Syntax.ClosedPattern+closedPatternClosedPattern = Typed.TypedName (Core.Name "hydra.python.syntax.ClosedPattern")+ -- | DSL injection for the group variant of hydra.python.syntax.ClosedPattern closedPatternGroup :: Typed.TypedTerm Syntax.GroupPattern -> Typed.TypedTerm Syntax.ClosedPattern closedPatternGroup x =@@ -1678,6 +1766,10 @@           Core.fieldName = (Core.Name "keywords"),           Core.fieldTerm = (Typed.unTypedTerm keywords)}]})) +-- | DSL name token for hydra.python.syntax.CommaStarEtc+commaStarEtcCommaStarEtc :: Typed.TypedName Syntax.CommaStarEtc+commaStarEtcCommaStarEtc = Typed.TypedName (Core.Name "hydra.python.syntax.CommaStarEtc")+ -- | DSL accessor for the keywords field of hydra.python.syntax.CommaStarEtc commaStarEtcKeywords :: Typed.TypedTerm Syntax.CommaStarEtc -> Typed.TypedTerm (Maybe Syntax.Keywords) commaStarEtcKeywords x =@@ -1743,6 +1835,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) +-- | DSL name token for hydra.python.syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPairCompareOpBitwiseOrPair :: Typed.TypedName Syntax.CompareOpBitwiseOrPair+compareOpBitwiseOrPairCompareOpBitwiseOrPair = Typed.TypedName (Core.Name "hydra.python.syntax.CompareOpBitwiseOrPair")+ -- | DSL accessor for the operator field of hydra.python.syntax.CompareOpBitwiseOrPair compareOpBitwiseOrPairOperator :: Typed.TypedTerm Syntax.CompareOpBitwiseOrPair -> Typed.TypedTerm Syntax.CompareOp compareOpBitwiseOrPairOperator x =@@ -1795,6 +1891,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.python.syntax.CompareOp+compareOpCompareOp :: Typed.TypedName Syntax.CompareOp+compareOpCompareOp = Typed.TypedName (Core.Name "hydra.python.syntax.CompareOp")+ -- | DSL injection for the eq variant of hydra.python.syntax.CompareOp compareOpEq :: Typed.TypedTerm Syntax.CompareOp compareOpEq =@@ -1898,6 +1998,10 @@           Core.fieldName = (Core.Name "rhs"),           Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) +-- | DSL name token for hydra.python.syntax.Comparison+comparisonComparison :: Typed.TypedName Syntax.Comparison+comparisonComparison = Typed.TypedName (Core.Name "hydra.python.syntax.Comparison")+ -- | DSL accessor for the lhs field of hydra.python.syntax.Comparison comparisonLhs :: Typed.TypedTerm Syntax.Comparison -> Typed.TypedTerm Syntax.BitwiseOr comparisonLhs x =@@ -1966,6 +2070,10 @@           Core.fieldName = (Core.Name "imaginary"),           Core.fieldTerm = (Typed.unTypedTerm imaginary)}]})) +-- | DSL name token for hydra.python.syntax.ComplexNumber+complexNumberComplexNumber :: Typed.TypedName Syntax.ComplexNumber+complexNumberComplexNumber = Typed.TypedName (Core.Name "hydra.python.syntax.ComplexNumber")+ -- | DSL accessor for the imaginary field of hydra.python.syntax.ComplexNumber complexNumberImaginary :: Typed.TypedTerm Syntax.ComplexNumber -> Typed.TypedTerm Syntax.ImaginaryNumber complexNumberImaginary x =@@ -2074,6 +2182,10 @@         Core.fieldName = (Core.Name "classDef"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.CompoundStatement+compoundStatementCompoundStatement :: Typed.TypedName Syntax.CompoundStatement+compoundStatementCompoundStatement = Typed.TypedName (Core.Name "hydra.python.syntax.CompoundStatement")+ -- | DSL injection for the for variant of hydra.python.syntax.CompoundStatement compoundStatementFor :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.CompoundStatement compoundStatementFor x =@@ -2162,6 +2274,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Conditional+conditionalConditional :: Typed.TypedName Syntax.Conditional+conditionalConditional = Typed.TypedName (Core.Name "hydra.python.syntax.Conditional")+ -- | DSL accessor for the else field of hydra.python.syntax.Conditional conditionalElse :: Typed.TypedTerm Syntax.Conditional -> Typed.TypedTerm Syntax.Expression conditionalElse x =@@ -2259,6 +2375,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Conjunction"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Conjunction+conjunctionConjunction :: Typed.TypedName Syntax.Conjunction+conjunctionConjunction = Typed.TypedName (Core.Name "hydra.python.syntax.Conjunction")+ -- | DSL constructor for the hydra.python.syntax.Decorators wrapper decorators :: Typed.TypedTerm [Syntax.NamedExpression] -> Typed.TypedTerm Syntax.Decorators decorators x =@@ -2266,6 +2386,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Decorators"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Decorators+decoratorsDecorators :: Typed.TypedName Syntax.Decorators+decoratorsDecorators = Typed.TypedName (Core.Name "hydra.python.syntax.Decorators")+ -- | DSL constructor for the hydra.python.syntax.Default wrapper default_ :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Default default_ x =@@ -2273,6 +2397,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Default"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Default+defaultDefault :: Typed.TypedName Syntax.Default+defaultDefault = Typed.TypedName (Core.Name "hydra.python.syntax.Default")+ -- | DSL constructor for the hydra.python.syntax.DelStatement wrapper delStatement :: Typed.TypedTerm Syntax.DelTargets -> Typed.TypedTerm Syntax.DelStatement delStatement x =@@ -2280,6 +2408,14 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.DelStatement"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.DelStatement+delStatementDelStatement :: Typed.TypedName Syntax.DelStatement+delStatementDelStatement = Typed.TypedName (Core.Name "hydra.python.syntax.DelStatement")++-- | DSL name token for hydra.python.syntax.DelTAtom+delTAtomDelTAtom :: Typed.TypedName Syntax.DelTAtom+delTAtomDelTAtom = Typed.TypedName (Core.Name "hydra.python.syntax.DelTAtom")+ -- | DSL injection for the name variant of hydra.python.syntax.DelTAtom delTAtomName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.DelTAtom delTAtomName x =@@ -2316,6 +2452,10 @@         Core.fieldName = (Core.Name "delTAtom"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.DelTarget+delTargetDelTarget :: Typed.TypedName Syntax.DelTarget+delTargetDelTarget = Typed.TypedName (Core.Name "hydra.python.syntax.DelTarget")+ -- | DSL injection for the primaryAndName variant of hydra.python.syntax.DelTarget delTargetPrimaryAndName :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.DelTarget delTargetPrimaryAndName x =@@ -2341,6 +2481,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.DelTargets"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.DelTargets+delTargetsDelTargets :: Typed.TypedName Syntax.DelTargets+delTargetsDelTargets = Typed.TypedName (Core.Name "hydra.python.syntax.DelTargets")+ -- | DSL constructor for the hydra.python.syntax.Dict wrapper dict :: Typed.TypedTerm [Syntax.DoubleStarredKvpair] -> Typed.TypedTerm Syntax.Dict dict x =@@ -2348,6 +2492,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Dict"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Dict+dictDict :: Typed.TypedName Syntax.Dict+dictDict = Typed.TypedName (Core.Name "hydra.python.syntax.Dict")+ -- | DSL constructor for hydra.python.syntax.Dictcomp dictcomp :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Dictcomp dictcomp kvpair forIfClauses =@@ -2361,6 +2509,10 @@           Core.fieldName = (Core.Name "forIfClauses"),           Core.fieldTerm = (Typed.unTypedTerm forIfClauses)}]})) +-- | DSL name token for hydra.python.syntax.Dictcomp+dictcompDictcomp :: Typed.TypedName Syntax.Dictcomp+dictcompDictcomp = Typed.TypedName (Core.Name "hydra.python.syntax.Dictcomp")+ -- | DSL accessor for the forIfClauses field of hydra.python.syntax.Dictcomp dictcompForIfClauses :: Typed.TypedTerm Syntax.Dictcomp -> Typed.TypedTerm Syntax.ForIfClauses dictcompForIfClauses x =@@ -2420,6 +2572,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Disjunction"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Disjunction+disjunctionDisjunction :: Typed.TypedName Syntax.Disjunction+disjunctionDisjunction = Typed.TypedName (Core.Name "hydra.python.syntax.Disjunction")+ -- | DSL constructor for hydra.python.syntax.DottedAsName dottedAsName :: Typed.TypedTerm Syntax.DottedName -> Typed.TypedTerm (Maybe Syntax.Name) -> Typed.TypedTerm Syntax.DottedAsName dottedAsName name as =@@ -2442,6 +2598,10 @@         Core.projectionFieldName = (Core.Name "as")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.DottedAsName+dottedAsNameDottedAsName :: Typed.TypedName Syntax.DottedAsName+dottedAsNameDottedAsName = Typed.TypedName (Core.Name "hydra.python.syntax.DottedAsName")+ -- | DSL accessor for the name field of hydra.python.syntax.DottedAsName dottedAsNameName :: Typed.TypedTerm Syntax.DottedAsName -> Typed.TypedTerm Syntax.DottedName dottedAsNameName x =@@ -2492,6 +2652,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.DottedName"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.DottedName+dottedNameDottedName :: Typed.TypedName Syntax.DottedName+dottedNameDottedName = Typed.TypedName (Core.Name "hydra.python.syntax.DottedName")+ -- | DSL constructor for the hydra.python.syntax.DoubleStarPattern wrapper doubleStarPattern :: Typed.TypedTerm Syntax.PatternCaptureTarget -> Typed.TypedTerm Syntax.DoubleStarPattern doubleStarPattern x =@@ -2499,6 +2663,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.DoubleStarPattern"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.DoubleStarPattern+doubleStarPatternDoubleStarPattern :: Typed.TypedName Syntax.DoubleStarPattern+doubleStarPatternDoubleStarPattern = Typed.TypedName (Core.Name "hydra.python.syntax.DoubleStarPattern")+ -- | DSL constructor for hydra.python.syntax.DoubleStarTypeParameter doubleStarTypeParameter :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.DoubleStarTypeParameter doubleStarTypeParameter name default_ =@@ -2521,6 +2689,10 @@         Core.projectionFieldName = (Core.Name "default")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.DoubleStarTypeParameter+doubleStarTypeParameterDoubleStarTypeParameter :: Typed.TypedName Syntax.DoubleStarTypeParameter+doubleStarTypeParameterDoubleStarTypeParameter = Typed.TypedName (Core.Name "hydra.python.syntax.DoubleStarTypeParameter")+ -- | DSL accessor for the name field of hydra.python.syntax.DoubleStarTypeParameter doubleStarTypeParameterName :: Typed.TypedTerm Syntax.DoubleStarTypeParameter -> Typed.TypedTerm Syntax.Name doubleStarTypeParameterName x =@@ -2564,6 +2736,10 @@               Core.projectionFieldName = (Core.Name "default")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL name token for hydra.python.syntax.DoubleStarredKvpair+doubleStarredKvpairDoubleStarredKvpair :: Typed.TypedName Syntax.DoubleStarredKvpair+doubleStarredKvpairDoubleStarredKvpair = Typed.TypedName (Core.Name "hydra.python.syntax.DoubleStarredKvpair")+ -- | DSL injection for the pair variant of hydra.python.syntax.DoubleStarredKvpair doubleStarredKvpairPair :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.DoubleStarredKvpair doubleStarredKvpairPair x =@@ -2589,6 +2765,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Eval"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Eval+evalEval :: Typed.TypedName Syntax.Eval+evalEval = Typed.TypedName (Core.Name "hydra.python.syntax.Eval")+ -- | DSL constructor for hydra.python.syntax.ExceptBlock exceptBlock :: Typed.TypedTerm (Maybe Syntax.ExceptExpression) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ExceptBlock exceptBlock expression body =@@ -2611,6 +2791,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ExceptBlock+exceptBlockExceptBlock :: Typed.TypedName Syntax.ExceptBlock+exceptBlockExceptBlock = Typed.TypedName (Core.Name "hydra.python.syntax.ExceptBlock")+ -- | DSL accessor for the expression field of hydra.python.syntax.ExceptBlock exceptBlockExpression :: Typed.TypedTerm Syntax.ExceptBlock -> Typed.TypedTerm (Maybe Syntax.ExceptExpression) exceptBlockExpression x =@@ -2676,6 +2860,10 @@         Core.projectionFieldName = (Core.Name "as")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ExceptExpression+exceptExpressionExceptExpression :: Typed.TypedName Syntax.ExceptExpression+exceptExpressionExceptExpression = Typed.TypedName (Core.Name "hydra.python.syntax.ExceptExpression")+ -- | DSL accessor for the expression field of hydra.python.syntax.ExceptExpression exceptExpressionExpression :: Typed.TypedTerm Syntax.ExceptExpression -> Typed.TypedTerm Syntax.Expression exceptExpressionExpression x =@@ -2753,6 +2941,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ExceptStarBlock+exceptStarBlockExceptStarBlock :: Typed.TypedName Syntax.ExceptStarBlock+exceptStarBlockExceptStarBlock = Typed.TypedName (Core.Name "hydra.python.syntax.ExceptStarBlock")+ -- | DSL accessor for the expression field of hydra.python.syntax.ExceptStarBlock exceptStarBlockExpression :: Typed.TypedTerm Syntax.ExceptStarBlock -> Typed.TypedTerm Syntax.Expression exceptStarBlockExpression x =@@ -2843,6 +3035,10 @@         Core.fieldName = (Core.Name "conditional"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Expression+expressionExpression :: Typed.TypedName Syntax.Expression+expressionExpression = Typed.TypedName (Core.Name "hydra.python.syntax.Expression")+ -- | DSL injection for the lambda variant of hydra.python.syntax.Expression expressionLambda :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm Syntax.Expression expressionLambda x =@@ -2870,6 +3066,10 @@         Core.fieldName = (Core.Name "complement"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Factor+factorFactor :: Typed.TypedName Syntax.Factor+factorFactor = Typed.TypedName (Core.Name "hydra.python.syntax.Factor")+ -- | DSL injection for the negative variant of hydra.python.syntax.Factor factorNegative :: Typed.TypedTerm Syntax.Factor -> Typed.TypedTerm Syntax.Factor factorNegative x =@@ -2904,6 +3104,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.File"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.File+fileFile :: Typed.TypedName Syntax.File+fileFile = Typed.TypedName (Core.Name "hydra.python.syntax.File")+ -- | DSL constructor for hydra.python.syntax.ForIfClause forIfClause :: Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.Disjunction -> Typed.TypedTerm [Syntax.Disjunction] -> Typed.TypedTerm Syntax.ForIfClause forIfClause async targets in_ ifs =@@ -2932,6 +3136,10 @@         Core.projectionFieldName = (Core.Name "async")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ForIfClause+forIfClauseForIfClause :: Typed.TypedName Syntax.ForIfClause+forIfClauseForIfClause = Typed.TypedName (Core.Name "hydra.python.syntax.ForIfClause")+ -- | DSL accessor for the ifs field of hydra.python.syntax.ForIfClause forIfClauseIfs :: Typed.TypedTerm Syntax.ForIfClause -> Typed.TypedTerm [Syntax.Disjunction] forIfClauseIfs x =@@ -3090,6 +3298,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ForIfClauses"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ForIfClauses+forIfClausesForIfClauses :: Typed.TypedName Syntax.ForIfClauses+forIfClausesForIfClauses = Typed.TypedName (Core.Name "hydra.python.syntax.ForIfClauses")+ -- | DSL constructor for hydra.python.syntax.ForStatement forStatement :: Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.ForStatement forStatement async targets expressions typeComment body else_ =@@ -3151,6 +3363,10 @@         Core.projectionFieldName = (Core.Name "expressions")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ForStatement+forStatementForStatement :: Typed.TypedName Syntax.ForStatement+forStatementForStatement = Typed.TypedName (Core.Name "hydra.python.syntax.ForStatement")+ -- | DSL accessor for the targets field of hydra.python.syntax.ForStatement forStatementTargets :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm [Syntax.StarTarget] forStatementTargets x =@@ -3446,6 +3662,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.FuncTypeComment"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.FuncTypeComment+funcTypeCommentFuncTypeComment :: Typed.TypedName Syntax.FuncTypeComment+funcTypeCommentFuncTypeComment = Typed.TypedName (Core.Name "hydra.python.syntax.FuncTypeComment")+ -- | DSL constructor for hydra.python.syntax.FunctionDefRaw functionDefRaw :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm (Maybe Syntax.Parameters) -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe Syntax.FuncTypeComment) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.FunctionDefRaw functionDefRaw async name typeParams params returnType funcTypeComment block =@@ -3501,6 +3721,10 @@         Core.projectionFieldName = (Core.Name "funcTypeComment")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.FunctionDefRaw+functionDefRawFunctionDefRaw :: Typed.TypedName Syntax.FunctionDefRaw+functionDefRawFunctionDefRaw = Typed.TypedName (Core.Name "hydra.python.syntax.FunctionDefRaw")+ -- | DSL accessor for the name field of hydra.python.syntax.FunctionDefRaw functionDefRawName :: Typed.TypedTerm Syntax.FunctionDefRaw -> Typed.TypedTerm Syntax.Name functionDefRawName x =@@ -3923,6 +4147,10 @@         Core.projectionFieldName = (Core.Name "decorators")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.FunctionDefinition+functionDefinitionFunctionDefinition :: Typed.TypedName Syntax.FunctionDefinition+functionDefinitionFunctionDefinition = Typed.TypedName (Core.Name "hydra.python.syntax.FunctionDefinition")+ -- | DSL accessor for the raw field of hydra.python.syntax.FunctionDefinition functionDefinitionRaw :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.FunctionDefRaw functionDefinitionRaw x =@@ -3979,6 +4207,10 @@           Core.fieldName = (Core.Name "tail"),           Core.fieldTerm = (Typed.unTypedTerm tail)}]})) +-- | DSL name token for hydra.python.syntax.Genexp+genexpGenexp :: Typed.TypedName Syntax.Genexp+genexpGenexp = Typed.TypedName (Core.Name "hydra.python.syntax.Genexp")+ -- | DSL accessor for the head field of hydra.python.syntax.Genexp genexpHead :: Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.GenexpHead genexpHead x =@@ -4006,6 +4238,10 @@         Core.fieldName = (Core.Name "expression"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.GenexpHead+genexpHeadGenexpHead :: Typed.TypedName Syntax.GenexpHead+genexpHeadGenexpHead = Typed.TypedName (Core.Name "hydra.python.syntax.GenexpHead")+ -- | DSL accessor for the tail field of hydra.python.syntax.Genexp genexpTail :: Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.ForIfClauses genexpTail x =@@ -4058,6 +4294,10 @@         Core.fieldName = (Core.Name "expression"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Group+groupGroup :: Typed.TypedName Syntax.Group+groupGroup = Typed.TypedName (Core.Name "hydra.python.syntax.Group")+ -- | DSL constructor for the hydra.python.syntax.GroupPattern wrapper groupPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.GroupPattern groupPattern x =@@ -4065,6 +4305,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.GroupPattern"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.GroupPattern+groupPatternGroupPattern :: Typed.TypedName Syntax.GroupPattern+groupPatternGroupPattern = Typed.TypedName (Core.Name "hydra.python.syntax.GroupPattern")+ -- | DSL injection for the yield variant of hydra.python.syntax.Group groupYield :: Typed.TypedTerm Syntax.YieldExpression -> Typed.TypedTerm Syntax.Group groupYield x =@@ -4081,6 +4325,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Guard"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Guard+guardGuard :: Typed.TypedName Syntax.Guard+guardGuard = Typed.TypedName (Core.Name "hydra.python.syntax.Guard")+ -- | DSL constructor for hydra.python.syntax.IfStatement ifStatement :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.IfTail) -> Typed.TypedTerm Syntax.IfStatement ifStatement condition body continuation =@@ -4124,6 +4372,10 @@         Core.projectionFieldName = (Core.Name "continuation")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.IfStatement+ifStatementIfStatement :: Typed.TypedName Syntax.IfStatement+ifStatementIfStatement = Typed.TypedName (Core.Name "hydra.python.syntax.IfStatement")+ -- | DSL updater for the body field of hydra.python.syntax.IfStatement ifStatementWithBody :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.IfStatement ifStatementWithBody original newVal =@@ -4214,6 +4466,10 @@         Core.fieldName = (Core.Name "else"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.IfTail+ifTailIfTail :: Typed.TypedName Syntax.IfTail+ifTailIfTail = Typed.TypedName (Core.Name "hydra.python.syntax.IfTail")+ -- | DSL constructor for the hydra.python.syntax.ImaginaryNumber wrapper imaginaryNumber :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.ImaginaryNumber imaginaryNumber x =@@ -4221,6 +4477,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ImaginaryNumber"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ImaginaryNumber+imaginaryNumberImaginaryNumber :: Typed.TypedName Syntax.ImaginaryNumber+imaginaryNumberImaginaryNumber = Typed.TypedName (Core.Name "hydra.python.syntax.ImaginaryNumber")+ -- | DSL constructor for hydra.python.syntax.ImportFrom importFrom :: Typed.TypedTerm [Syntax.RelativeImportPrefix] -> Typed.TypedTerm (Maybe Syntax.DottedName) -> Typed.TypedTerm Syntax.ImportFromTargets -> Typed.TypedTerm Syntax.ImportFrom importFrom prefixes dottedName targets =@@ -4259,6 +4519,10 @@         Core.projectionFieldName = (Core.Name "as")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ImportFromAsName+importFromAsNameImportFromAsName :: Typed.TypedName Syntax.ImportFromAsName+importFromAsNameImportFromAsName = Typed.TypedName (Core.Name "hydra.python.syntax.ImportFromAsName")+ -- | DSL accessor for the name field of hydra.python.syntax.ImportFromAsName importFromAsNameName :: Typed.TypedTerm Syntax.ImportFromAsName -> Typed.TypedTerm Syntax.Name importFromAsNameName x =@@ -4311,6 +4575,10 @@         Core.projectionFieldName = (Core.Name "dottedName")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ImportFrom+importFromImportFrom :: Typed.TypedName Syntax.ImportFrom+importFromImportFrom = Typed.TypedName (Core.Name "hydra.python.syntax.ImportFrom")+ -- | DSL accessor for the prefixes field of hydra.python.syntax.ImportFrom importFromPrefixes :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm [Syntax.RelativeImportPrefix] importFromPrefixes x =@@ -4329,6 +4597,10 @@         Core.projectionFieldName = (Core.Name "targets")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ImportFromTargets+importFromTargetsImportFromTargets :: Typed.TypedName Syntax.ImportFromTargets+importFromTargetsImportFromTargets = Typed.TypedName (Core.Name "hydra.python.syntax.ImportFromTargets")+ -- | DSL injection for the parens variant of hydra.python.syntax.ImportFromTargets importFromTargetsParens :: Typed.TypedTerm [Syntax.ImportFromAsName] -> Typed.TypedTerm Syntax.ImportFromTargets importFromTargetsParens x =@@ -4435,6 +4707,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ImportName"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ImportName+importNameImportName :: Typed.TypedName Syntax.ImportName+importNameImportName = Typed.TypedName (Core.Name "hydra.python.syntax.ImportName")+ -- | DSL injection for the from variant of hydra.python.syntax.ImportStatement importStatementFrom :: Typed.TypedTerm Syntax.ImportFrom -> Typed.TypedTerm Syntax.ImportStatement importStatementFrom x =@@ -4444,6 +4720,10 @@         Core.fieldName = (Core.Name "from"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.ImportStatement+importStatementImportStatement :: Typed.TypedName Syntax.ImportStatement+importStatementImportStatement = Typed.TypedName (Core.Name "hydra.python.syntax.ImportStatement")+ -- | DSL injection for the name variant of hydra.python.syntax.ImportStatement importStatementName :: Typed.TypedTerm Syntax.ImportName -> Typed.TypedTerm Syntax.ImportStatement importStatementName x =@@ -4460,6 +4740,14 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Interactive"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Interactive+interactiveInteractive :: Typed.TypedName Syntax.Interactive+interactiveInteractive = Typed.TypedName (Core.Name "hydra.python.syntax.Interactive")++-- | DSL name token for hydra.python.syntax.Inversion+inversionInversion :: Typed.TypedName Syntax.Inversion+inversionInversion = Typed.TypedName (Core.Name "hydra.python.syntax.Inversion")+ -- | DSL injection for the not variant of hydra.python.syntax.Inversion inversionNot :: Typed.TypedTerm Syntax.Inversion -> Typed.TypedTerm Syntax.Inversion inversionNot x =@@ -4485,6 +4773,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ItemsPattern"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ItemsPattern+itemsPatternItemsPattern :: Typed.TypedName Syntax.ItemsPattern+itemsPatternItemsPattern = Typed.TypedName (Core.Name "hydra.python.syntax.ItemsPattern")+ -- | DSL constructor for hydra.python.syntax.KeyValuePattern keyValuePattern :: Typed.TypedTerm Syntax.LiteralExpressionOrAttribute -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.KeyValuePattern keyValuePattern key value =@@ -4507,6 +4799,10 @@         Core.projectionFieldName = (Core.Name "key")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.KeyValuePattern+keyValuePatternKeyValuePattern :: Typed.TypedName Syntax.KeyValuePattern+keyValuePatternKeyValuePattern = Typed.TypedName (Core.Name "hydra.python.syntax.KeyValuePattern")+ -- | DSL accessor for the value field of hydra.python.syntax.KeyValuePattern keyValuePatternValue :: Typed.TypedTerm Syntax.KeyValuePattern -> Typed.TypedTerm Syntax.Pattern keyValuePatternValue x =@@ -4563,6 +4859,10 @@           Core.fieldName = (Core.Name "pattern"),           Core.fieldTerm = (Typed.unTypedTerm pattern)}]})) +-- | DSL name token for hydra.python.syntax.KeywordPattern+keywordPatternKeywordPattern :: Typed.TypedName Syntax.KeywordPattern+keywordPatternKeywordPattern = Typed.TypedName (Core.Name "hydra.python.syntax.KeywordPattern")+ -- | DSL accessor for the name field of hydra.python.syntax.KeywordPattern keywordPatternName :: Typed.TypedTerm Syntax.KeywordPattern -> Typed.TypedTerm Syntax.Name keywordPatternName x =@@ -4622,6 +4922,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.KeywordPatterns"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.KeywordPatterns+keywordPatternsKeywordPatterns :: Typed.TypedName Syntax.KeywordPatterns+keywordPatternsKeywordPatterns = Typed.TypedName (Core.Name "hydra.python.syntax.KeywordPatterns")+ -- | DSL constructor for the hydra.python.syntax.Keywords wrapper keywords :: Typed.TypedTerm Syntax.ParamNoDefault -> Typed.TypedTerm Syntax.Keywords keywords x =@@ -4629,6 +4933,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Keywords"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Keywords+keywordsKeywords :: Typed.TypedName Syntax.Keywords+keywordsKeywords = Typed.TypedName (Core.Name "hydra.python.syntax.Keywords")+ -- | DSL constructor for hydra.python.syntax.Kvpair kvpair :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Kvpair kvpair key value =@@ -4651,6 +4959,10 @@         Core.projectionFieldName = (Core.Name "key")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Kvpair+kvpairKvpair :: Typed.TypedName Syntax.Kvpair+kvpairKvpair = Typed.TypedName (Core.Name "hydra.python.syntax.Kvpair")+ -- | DSL accessor for the value field of hydra.python.syntax.Kvpair kvpairValue :: Typed.TypedTerm Syntax.Kvpair -> Typed.TypedTerm Syntax.Expression kvpairValue x =@@ -4707,6 +5019,10 @@           Core.fieldName = (Core.Name "value"),           Core.fieldTerm = (Typed.unTypedTerm value)}]})) +-- | DSL name token for hydra.python.syntax.Kwarg+kwargKwarg :: Typed.TypedName Syntax.Kwarg+kwargKwarg = Typed.TypedName (Core.Name "hydra.python.syntax.Kwarg")+ -- | DSL accessor for the name field of hydra.python.syntax.Kwarg kwargName :: Typed.TypedTerm Syntax.Kwarg -> Typed.TypedTerm Syntax.Name kwargName x =@@ -4734,6 +5050,10 @@         Core.fieldName = (Core.Name "kwarg"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.KwargOrDoubleStarred+kwargOrDoubleStarredKwargOrDoubleStarred :: Typed.TypedName Syntax.KwargOrDoubleStarred+kwargOrDoubleStarredKwargOrDoubleStarred = Typed.TypedName (Core.Name "hydra.python.syntax.KwargOrDoubleStarred")+ -- | DSL injection for the kwarg variant of hydra.python.syntax.KwargOrStarred kwargOrStarredKwarg :: Typed.TypedTerm Syntax.Kwarg -> Typed.TypedTerm Syntax.KwargOrStarred kwargOrStarredKwarg x =@@ -4743,6 +5063,10 @@         Core.fieldName = (Core.Name "kwarg"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.KwargOrStarred+kwargOrStarredKwargOrStarred :: Typed.TypedName Syntax.KwargOrStarred+kwargOrStarredKwargOrStarred = Typed.TypedName (Core.Name "hydra.python.syntax.KwargOrStarred")+ -- | DSL injection for the starred variant of hydra.python.syntax.KwargOrStarred kwargOrStarredStarred :: Typed.TypedTerm Syntax.StarredExpression -> Typed.TypedTerm Syntax.KwargOrStarred kwargOrStarredStarred x =@@ -4824,6 +5148,14 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.LambdaKwds"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.LambdaKwds+lambdaKwdsLambdaKwds :: Typed.TypedName Syntax.LambdaKwds+lambdaKwdsLambdaKwds = Typed.TypedName (Core.Name "hydra.python.syntax.LambdaKwds")++-- | DSL name token for hydra.python.syntax.Lambda+lambdaLambda :: Typed.TypedName Syntax.Lambda+lambdaLambda = Typed.TypedName (Core.Name "hydra.python.syntax.Lambda")+ -- | DSL constructor for hydra.python.syntax.LambdaParamMaybeDefault lambdaParamMaybeDefault :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Default) -> Typed.TypedTerm Syntax.LambdaParamMaybeDefault lambdaParamMaybeDefault param default_ =@@ -4846,6 +5178,10 @@         Core.projectionFieldName = (Core.Name "default")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefaultLambdaParamMaybeDefault :: Typed.TypedName Syntax.LambdaParamMaybeDefault+lambdaParamMaybeDefaultLambdaParamMaybeDefault = Typed.TypedName (Core.Name "hydra.python.syntax.LambdaParamMaybeDefault")+ -- | DSL accessor for the param field of hydra.python.syntax.LambdaParamMaybeDefault lambdaParamMaybeDefaultParam :: Typed.TypedTerm Syntax.LambdaParamMaybeDefault -> Typed.TypedTerm Syntax.Name lambdaParamMaybeDefaultParam x =@@ -4896,6 +5232,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.LambdaParamNoDefault"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.LambdaParamNoDefault+lambdaParamNoDefaultLambdaParamNoDefault :: Typed.TypedName Syntax.LambdaParamNoDefault+lambdaParamNoDefaultLambdaParamNoDefault = Typed.TypedName (Core.Name "hydra.python.syntax.LambdaParamNoDefault")+ -- | DSL constructor for hydra.python.syntax.LambdaParamWithDefault lambdaParamWithDefault :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Default) -> Typed.TypedTerm Syntax.LambdaParamWithDefault lambdaParamWithDefault param default_ =@@ -4918,6 +5258,10 @@         Core.projectionFieldName = (Core.Name "default")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.LambdaParamWithDefault+lambdaParamWithDefaultLambdaParamWithDefault :: Typed.TypedName Syntax.LambdaParamWithDefault+lambdaParamWithDefaultLambdaParamWithDefault = Typed.TypedName (Core.Name "hydra.python.syntax.LambdaParamWithDefault")+ -- | DSL accessor for the param field of hydra.python.syntax.LambdaParamWithDefault lambdaParamWithDefaultParam :: Typed.TypedTerm Syntax.LambdaParamWithDefault -> Typed.TypedTerm Syntax.Name lambdaParamWithDefaultParam x =@@ -4980,6 +5324,10 @@           Core.fieldName = (Core.Name "starEtc"),           Core.fieldTerm = (Typed.unTypedTerm starEtc)}]})) +-- | DSL name token for hydra.python.syntax.LambdaParameters+lambdaParametersLambdaParameters :: Typed.TypedName Syntax.LambdaParameters+lambdaParametersLambdaParameters = Typed.TypedName (Core.Name "hydra.python.syntax.LambdaParameters")+ -- | DSL accessor for the paramNoDefault field of hydra.python.syntax.LambdaParameters lambdaParametersParamNoDefault :: Typed.TypedTerm Syntax.LambdaParameters -> Typed.TypedTerm [Syntax.LambdaParamNoDefault] lambdaParametersParamNoDefault x =@@ -5159,6 +5507,10 @@           Core.fieldName = (Core.Name "parameters"),           Core.fieldTerm = (Typed.unTypedTerm parameters)}]})) +-- | DSL name token for hydra.python.syntax.LambdaSlashNoDefault+lambdaSlashNoDefaultLambdaSlashNoDefault :: Typed.TypedName Syntax.LambdaSlashNoDefault+lambdaSlashNoDefaultLambdaSlashNoDefault = Typed.TypedName (Core.Name "hydra.python.syntax.LambdaSlashNoDefault")+ -- | DSL accessor for the parameters field of hydra.python.syntax.LambdaSlashNoDefault lambdaSlashNoDefaultParameters :: Typed.TypedTerm Syntax.LambdaSlashNoDefault -> Typed.TypedTerm [Syntax.LambdaParamNoDefault] lambdaSlashNoDefaultParameters x =@@ -5191,6 +5543,10 @@           Core.fieldName = (Core.Name "paramWithDefault"),           Core.fieldTerm = (Typed.unTypedTerm paramWithDefault)}]})) +-- | DSL name token for hydra.python.syntax.LambdaSlashWithDefault+lambdaSlashWithDefaultLambdaSlashWithDefault :: Typed.TypedName Syntax.LambdaSlashWithDefault+lambdaSlashWithDefaultLambdaSlashWithDefault = Typed.TypedName (Core.Name "hydra.python.syntax.LambdaSlashWithDefault")+ -- | DSL accessor for the paramNoDefault field of hydra.python.syntax.LambdaSlashWithDefault lambdaSlashWithDefaultParamNoDefault :: Typed.TypedTerm Syntax.LambdaSlashWithDefault -> Typed.TypedTerm [Syntax.LambdaParamNoDefault] lambdaSlashWithDefaultParamNoDefault x =@@ -5252,6 +5608,10 @@         Core.fieldName = (Core.Name "kwds"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.LambdaStarEtc+lambdaStarEtcLambdaStarEtc :: Typed.TypedName Syntax.LambdaStarEtc+lambdaStarEtcLambdaStarEtc = Typed.TypedName (Core.Name "hydra.python.syntax.LambdaStarEtc")+ -- | DSL injection for the paramMaybeDefault variant of hydra.python.syntax.LambdaStarEtc lambdaStarEtcParamMaybeDefault :: Typed.TypedTerm [Syntax.LambdaParamMaybeDefault] -> Typed.TypedTerm Syntax.LambdaStarEtc lambdaStarEtcParamMaybeDefault x =@@ -5320,6 +5680,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.List"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.List+listList :: Typed.TypedName Syntax.List+listList = Typed.TypedName (Core.Name "hydra.python.syntax.List")+ -- | DSL constructor for hydra.python.syntax.Listcomp listcomp :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Listcomp listcomp expression forIfClauses =@@ -5351,6 +5715,10 @@         Core.projectionFieldName = (Core.Name "forIfClauses")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Listcomp+listcompListcomp :: Typed.TypedName Syntax.Listcomp+listcompListcomp = Typed.TypedName (Core.Name "hydra.python.syntax.Listcomp")+ -- | DSL updater for the expression field of hydra.python.syntax.Listcomp listcompWithExpression :: Typed.TypedTerm Syntax.Listcomp -> Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Listcomp listcompWithExpression original newVal =@@ -5403,6 +5771,10 @@         Core.fieldName = (Core.Name "false"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.LiteralExpression+literalExpressionLiteralExpression :: Typed.TypedName Syntax.LiteralExpression+literalExpressionLiteralExpression = Typed.TypedName (Core.Name "hydra.python.syntax.LiteralExpression")+ -- | DSL injection for the none variant of hydra.python.syntax.LiteralExpression literalExpressionNone :: Typed.TypedTerm Syntax.LiteralExpression literalExpressionNone =@@ -5439,6 +5811,11 @@         Core.fieldName = (Core.Name "literal"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.LiteralExpressionOrAttribute+literalExpressionOrAttributeLiteralExpressionOrAttribute :: Typed.TypedName Syntax.LiteralExpressionOrAttribute+literalExpressionOrAttributeLiteralExpressionOrAttribute =+    Typed.TypedName (Core.Name "hydra.python.syntax.LiteralExpressionOrAttribute")+ -- | DSL injection for the string variant of hydra.python.syntax.LiteralExpression literalExpressionString :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm Syntax.LiteralExpression literalExpressionString x =@@ -5488,6 +5865,10 @@         Core.projectionFieldName = (Core.Name "items")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.MappingPattern+mappingPatternMappingPattern :: Typed.TypedName Syntax.MappingPattern+mappingPatternMappingPattern = Typed.TypedName (Core.Name "hydra.python.syntax.MappingPattern")+ -- | DSL updater for the doubleStar field of hydra.python.syntax.MappingPattern mappingPatternWithDoubleStar :: Typed.TypedTerm Syntax.MappingPattern -> Typed.TypedTerm (Maybe Syntax.DoubleStarPattern) -> Typed.TypedTerm Syntax.MappingPattern mappingPatternWithDoubleStar original newVal =@@ -5544,6 +5925,10 @@         Core.projectionFieldName = (Core.Name "cases")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.MatchStatement+matchStatementMatchStatement :: Typed.TypedName Syntax.MatchStatement+matchStatementMatchStatement = Typed.TypedName (Core.Name "hydra.python.syntax.MatchStatement")+ -- | DSL accessor for the subject field of hydra.python.syntax.MatchStatement matchStatementSubject :: Typed.TypedTerm Syntax.MatchStatement -> Typed.TypedTerm Syntax.SubjectExpression matchStatementSubject x =@@ -5594,6 +5979,14 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.MaybeSequencePattern"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.MaybeSequencePattern+maybeSequencePatternMaybeSequencePattern :: Typed.TypedName Syntax.MaybeSequencePattern+maybeSequencePatternMaybeSequencePattern = Typed.TypedName (Core.Name "hydra.python.syntax.MaybeSequencePattern")++-- | DSL name token for hydra.python.syntax.MaybeStarPattern+maybeStarPatternMaybeStarPattern :: Typed.TypedName Syntax.MaybeStarPattern+maybeStarPatternMaybeStarPattern = Typed.TypedName (Core.Name "hydra.python.syntax.MaybeStarPattern")+ -- | DSL injection for the pattern variant of hydra.python.syntax.MaybeStarPattern maybeStarPatternPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.MaybeStarPattern maybeStarPatternPattern x =@@ -5619,6 +6012,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Module"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Module+moduleModule :: Typed.TypedName Syntax.Module+moduleModule = Typed.TypedName (Core.Name "hydra.python.syntax.Module")+ -- | DSL constructor for the hydra.python.syntax.Name wrapper name :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Name name x =@@ -5626,6 +6023,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Name"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Name+nameName :: Typed.TypedName Syntax.Name+nameName = Typed.TypedName (Core.Name "hydra.python.syntax.Name")+ -- | DSL constructor for the hydra.python.syntax.NameOrAttribute wrapper nameOrAttribute :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.NameOrAttribute nameOrAttribute x =@@ -5633,6 +6034,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.NameOrAttribute"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.NameOrAttribute+nameOrAttributeNameOrAttribute :: Typed.TypedName Syntax.NameOrAttribute+nameOrAttributeNameOrAttribute = Typed.TypedName (Core.Name "hydra.python.syntax.NameOrAttribute")+ -- | DSL injection for the assignment variant of hydra.python.syntax.NamedExpression namedExpressionAssignment :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.NamedExpression namedExpressionAssignment x =@@ -5642,6 +6047,10 @@         Core.fieldName = (Core.Name "assignment"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.NamedExpression+namedExpressionNamedExpression :: Typed.TypedName Syntax.NamedExpression+namedExpressionNamedExpression = Typed.TypedName (Core.Name "hydra.python.syntax.NamedExpression")+ -- | DSL injection for the simple variant of hydra.python.syntax.NamedExpression namedExpressionSimple :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.NamedExpression namedExpressionSimple x =@@ -5676,6 +6085,11 @@         Core.projectionFieldName = (Core.Name "keywords")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcNoDefaultStarAnnotationStarEtc :: Typed.TypedName Syntax.NoDefaultStarAnnotationStarEtc+noDefaultStarAnnotationStarEtcNoDefaultStarAnnotationStarEtc =+    Typed.TypedName (Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc")+ -- | DSL accessor for the paramMaybeDefault field of hydra.python.syntax.NoDefaultStarAnnotationStarEtc noDefaultStarAnnotationStarEtcParamMaybeDefault :: Typed.TypedTerm Syntax.NoDefaultStarAnnotationStarEtc -> Typed.TypedTerm [Syntax.ParamMaybeDefault] noDefaultStarAnnotationStarEtcParamMaybeDefault x =@@ -5791,6 +6205,10 @@         Core.projectionFieldName = (Core.Name "keywords")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.NoDefaultStarEtc+noDefaultStarEtcNoDefaultStarEtc :: Typed.TypedName Syntax.NoDefaultStarEtc+noDefaultStarEtcNoDefaultStarEtc = Typed.TypedName (Core.Name "hydra.python.syntax.NoDefaultStarEtc")+ -- | DSL accessor for the paramMaybeDefault field of hydra.python.syntax.NoDefaultStarEtc noDefaultStarEtcParamMaybeDefault :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm [Syntax.ParamMaybeDefault] noDefaultStarEtcParamMaybeDefault x =@@ -5908,6 +6326,10 @@         Core.fieldName = (Core.Name "integer"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Number+numberNumber :: Typed.TypedName Syntax.Number+numberNumber = Typed.TypedName (Core.Name "hydra.python.syntax.Number")+ -- | DSL constructor for hydra.python.syntax.OpenSequencePattern openSequencePattern :: Typed.TypedTerm Syntax.MaybeStarPattern -> Typed.TypedTerm (Maybe Syntax.MaybeSequencePattern) -> Typed.TypedTerm Syntax.OpenSequencePattern openSequencePattern head tail =@@ -5930,6 +6352,10 @@         Core.projectionFieldName = (Core.Name "head")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.OpenSequencePattern+openSequencePatternOpenSequencePattern :: Typed.TypedName Syntax.OpenSequencePattern+openSequencePatternOpenSequencePattern = Typed.TypedName (Core.Name "hydra.python.syntax.OpenSequencePattern")+ -- | DSL accessor for the tail field of hydra.python.syntax.OpenSequencePattern openSequencePatternTail :: Typed.TypedTerm Syntax.OpenSequencePattern -> Typed.TypedTerm (Maybe Syntax.MaybeSequencePattern) openSequencePatternTail x =@@ -5980,6 +6406,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.OrPattern"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.OrPattern+orPatternOrPattern :: Typed.TypedName Syntax.OrPattern+orPatternOrPattern = Typed.TypedName (Core.Name "hydra.python.syntax.OrPattern")+ -- | DSL constructor for hydra.python.syntax.Param param :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.Annotation) -> Typed.TypedTerm Syntax.Param param name annotation =@@ -6036,6 +6466,10 @@         Core.projectionFieldName = (Core.Name "param")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ParamMaybeDefault+paramMaybeDefaultParamMaybeDefault :: Typed.TypedName Syntax.ParamMaybeDefault+paramMaybeDefaultParamMaybeDefault = Typed.TypedName (Core.Name "hydra.python.syntax.ParamMaybeDefault")+ -- | DSL accessor for the typeComment field of hydra.python.syntax.ParamMaybeDefault paramMaybeDefaultTypeComment :: Typed.TypedTerm Syntax.ParamMaybeDefault -> Typed.TypedTerm (Maybe Syntax.TypeComment) paramMaybeDefaultTypeComment x =@@ -6148,6 +6582,10 @@         Core.projectionFieldName = (Core.Name "param")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ParamNoDefault+paramNoDefaultParamNoDefault :: Typed.TypedName Syntax.ParamNoDefault+paramNoDefaultParamNoDefault = Typed.TypedName (Core.Name "hydra.python.syntax.ParamNoDefault")+ -- | DSL constructor for hydra.python.syntax.ParamNoDefaultParameters paramNoDefaultParameters :: Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.ParamNoDefaultParameters paramNoDefaultParameters paramNoDefault paramWithDefault starEtc =@@ -6173,6 +6611,11 @@         Core.projectionFieldName = (Core.Name "paramNoDefault")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ParamNoDefaultParameters+paramNoDefaultParametersParamNoDefaultParameters :: Typed.TypedName Syntax.ParamNoDefaultParameters+paramNoDefaultParametersParamNoDefaultParameters =+    Typed.TypedName (Core.Name "hydra.python.syntax.ParamNoDefaultParameters")+ -- | DSL accessor for the paramWithDefault field of hydra.python.syntax.ParamNoDefaultParameters paramNoDefaultParametersParamWithDefault :: Typed.TypedTerm Syntax.ParamNoDefaultParameters -> Typed.TypedTerm [Syntax.ParamWithDefault] paramNoDefaultParametersParamWithDefault x =@@ -6276,6 +6719,11 @@           Core.fieldName = (Core.Name "typeComment"),           Core.fieldTerm = (Typed.unTypedTerm typeComment)}]})) +-- | DSL name token for hydra.python.syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotationParamNoDefaultStarAnnotation :: Typed.TypedName Syntax.ParamNoDefaultStarAnnotation+paramNoDefaultStarAnnotationParamNoDefaultStarAnnotation =+    Typed.TypedName (Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation")+ -- | DSL accessor for the paramStarAnnotation field of hydra.python.syntax.ParamNoDefaultStarAnnotation paramNoDefaultStarAnnotationParamStarAnnotation :: Typed.TypedTerm Syntax.ParamNoDefaultStarAnnotation -> Typed.TypedTerm Syntax.ParamStarAnnotation paramNoDefaultStarAnnotationParamStarAnnotation x =@@ -6371,6 +6819,10 @@           Core.fieldName = (Core.Name "typeComment"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.python.syntax.Param+paramParam :: Typed.TypedName Syntax.Param+paramParam = Typed.TypedName (Core.Name "hydra.python.syntax.Param")+ -- | DSL constructor for hydra.python.syntax.ParamStarAnnotation paramStarAnnotation :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.StarAnnotation -> Typed.TypedTerm Syntax.ParamStarAnnotation paramStarAnnotation name annotation =@@ -6402,6 +6854,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ParamStarAnnotation+paramStarAnnotationParamStarAnnotation :: Typed.TypedName Syntax.ParamStarAnnotation+paramStarAnnotationParamStarAnnotation = Typed.TypedName (Core.Name "hydra.python.syntax.ParamStarAnnotation")+ -- | DSL updater for the annotation field of hydra.python.syntax.ParamStarAnnotation paramStarAnnotationWithAnnotation :: Typed.TypedTerm Syntax.ParamStarAnnotation -> Typed.TypedTerm Syntax.StarAnnotation -> Typed.TypedTerm Syntax.ParamStarAnnotation paramStarAnnotationWithAnnotation original newVal =@@ -6487,6 +6943,10 @@         Core.projectionFieldName = (Core.Name "param")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ParamWithDefault+paramWithDefaultParamWithDefault :: Typed.TypedName Syntax.ParamWithDefault+paramWithDefaultParamWithDefault = Typed.TypedName (Core.Name "hydra.python.syntax.ParamWithDefault")+ -- | DSL constructor for hydra.python.syntax.ParamWithDefaultParameters paramWithDefaultParameters :: Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm (Maybe Syntax.StarEtc) -> Typed.TypedTerm Syntax.ParamWithDefaultParameters paramWithDefaultParameters paramWithDefault starEtc =@@ -6509,6 +6969,11 @@         Core.projectionFieldName = (Core.Name "paramWithDefault")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ParamWithDefaultParameters+paramWithDefaultParametersParamWithDefaultParameters :: Typed.TypedName Syntax.ParamWithDefaultParameters+paramWithDefaultParametersParamWithDefaultParameters =+    Typed.TypedName (Core.Name "hydra.python.syntax.ParamWithDefaultParameters")+ -- | DSL accessor for the starEtc field of hydra.python.syntax.ParamWithDefaultParameters paramWithDefaultParametersStarEtc :: Typed.TypedTerm Syntax.ParamWithDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc) paramWithDefaultParametersStarEtc x =@@ -6668,6 +7133,10 @@         Core.fieldName = (Core.Name "paramWithDefault"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Parameters+parametersParameters :: Typed.TypedName Syntax.Parameters+parametersParameters = Typed.TypedName (Core.Name "hydra.python.syntax.Parameters")+ -- | DSL injection for the slashNoDefault variant of hydra.python.syntax.Parameters parametersSlashNoDefault :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm Syntax.Parameters parametersSlashNoDefault x =@@ -6711,6 +7180,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.PatternCaptureTarget"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.PatternCaptureTarget+patternCaptureTargetPatternCaptureTarget :: Typed.TypedName Syntax.PatternCaptureTarget+patternCaptureTargetPatternCaptureTarget = Typed.TypedName (Core.Name "hydra.python.syntax.PatternCaptureTarget")+ -- | DSL injection for the or variant of hydra.python.syntax.Pattern patternOr :: Typed.TypedTerm Syntax.OrPattern -> Typed.TypedTerm Syntax.Pattern patternOr x =@@ -6720,6 +7193,10 @@         Core.fieldName = (Core.Name "or"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Pattern+patternPattern :: Typed.TypedName Syntax.Pattern+patternPattern = Typed.TypedName (Core.Name "hydra.python.syntax.Pattern")+ -- | DSL injection for the pattern variant of hydra.python.syntax.Patterns patternsPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.Patterns patternsPattern x =@@ -6729,6 +7206,10 @@         Core.fieldName = (Core.Name "pattern"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Patterns+patternsPatterns :: Typed.TypedName Syntax.Patterns+patternsPatterns = Typed.TypedName (Core.Name "hydra.python.syntax.Patterns")+ -- | DSL injection for the sequence variant of hydra.python.syntax.Patterns patternsSequence :: Typed.TypedTerm Syntax.OpenSequencePattern -> Typed.TypedTerm Syntax.Patterns patternsSequence x =@@ -6756,6 +7237,10 @@         Core.fieldName = (Core.Name "plus"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.PlusOrMinus+plusOrMinusPlusOrMinus :: Typed.TypedName Syntax.PlusOrMinus+plusOrMinusPlusOrMinus = Typed.TypedName (Core.Name "hydra.python.syntax.PlusOrMinus")+ -- | DSL injection for the assignment variant of hydra.python.syntax.PosArg posArgAssignment :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.PosArg posArgAssignment x =@@ -6774,6 +7259,10 @@         Core.fieldName = (Core.Name "expression"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.PosArg+posArgPosArg :: Typed.TypedName Syntax.PosArg+posArgPosArg = Typed.TypedName (Core.Name "hydra.python.syntax.PosArg")+ -- | DSL injection for the starred variant of hydra.python.syntax.PosArg posArgStarred :: Typed.TypedTerm Syntax.StarredExpression -> Typed.TypedTerm Syntax.PosArg posArgStarred x =@@ -6790,6 +7279,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.PositionalPatterns"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.PositionalPatterns+positionalPatternsPositionalPatterns :: Typed.TypedName Syntax.PositionalPatterns+positionalPatternsPositionalPatterns = Typed.TypedName (Core.Name "hydra.python.syntax.PositionalPatterns")+ -- | DSL constructor for hydra.python.syntax.Power power :: Typed.TypedTerm Syntax.AwaitPrimary -> Typed.TypedTerm (Maybe Syntax.Factor) -> Typed.TypedTerm Syntax.Power power lhs rhs =@@ -6812,6 +7305,10 @@         Core.projectionFieldName = (Core.Name "lhs")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Power+powerPower :: Typed.TypedName Syntax.Power+powerPower = Typed.TypedName (Core.Name "hydra.python.syntax.Power")+ -- | DSL accessor for the rhs field of hydra.python.syntax.Power powerRhs :: Typed.TypedTerm Syntax.Power -> Typed.TypedTerm (Maybe Syntax.Factor) powerRhs x =@@ -6864,6 +7361,10 @@         Core.fieldName = (Core.Name "compound"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Primary+primaryPrimary :: Typed.TypedName Syntax.Primary+primaryPrimary = Typed.TypedName (Core.Name "hydra.python.syntax.Primary")+ -- | DSL injection for the call variant of hydra.python.syntax.PrimaryRhs primaryRhsCall :: Typed.TypedTerm Syntax.Args -> Typed.TypedTerm Syntax.PrimaryRhs primaryRhsCall x =@@ -6882,6 +7383,10 @@         Core.fieldName = (Core.Name "genexp"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.PrimaryRhs+primaryRhsPrimaryRhs :: Typed.TypedName Syntax.PrimaryRhs+primaryRhsPrimaryRhs = Typed.TypedName (Core.Name "hydra.python.syntax.PrimaryRhs")+ -- | DSL injection for the project variant of hydra.python.syntax.PrimaryRhs primaryRhsProject :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PrimaryRhs primaryRhsProject x =@@ -6931,6 +7436,10 @@         Core.projectionFieldName = (Core.Name "primary")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.PrimaryWithRhs+primaryWithRhsPrimaryWithRhs :: Typed.TypedName Syntax.PrimaryWithRhs+primaryWithRhsPrimaryWithRhs = Typed.TypedName (Core.Name "hydra.python.syntax.PrimaryWithRhs")+ -- | DSL accessor for the rhs field of hydra.python.syntax.PrimaryWithRhs primaryWithRhsRhs :: Typed.TypedTerm Syntax.PrimaryWithRhs -> Typed.TypedTerm Syntax.PrimaryRhs primaryWithRhsRhs x =@@ -6983,6 +7492,10 @@         Core.fieldName = (Core.Name "double"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.QuoteStyle+quoteStyleQuoteStyle :: Typed.TypedName Syntax.QuoteStyle+quoteStyleQuoteStyle = Typed.TypedName (Core.Name "hydra.python.syntax.QuoteStyle")+ -- | DSL injection for the single variant of hydra.python.syntax.QuoteStyle quoteStyleSingle :: Typed.TypedTerm Syntax.QuoteStyle quoteStyleSingle =@@ -7041,6 +7554,10 @@         Core.projectionFieldName = (Core.Name "from")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.RaiseExpression+raiseExpressionRaiseExpression :: Typed.TypedName Syntax.RaiseExpression+raiseExpressionRaiseExpression = Typed.TypedName (Core.Name "hydra.python.syntax.RaiseExpression")+ -- | DSL updater for the expression field of hydra.python.syntax.RaiseExpression raiseExpressionWithExpression :: Typed.TypedTerm Syntax.RaiseExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RaiseExpression raiseExpressionWithExpression original newVal =@@ -7082,6 +7599,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.RaiseStatement"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.RaiseStatement+raiseStatementRaiseStatement :: Typed.TypedName Syntax.RaiseStatement+raiseStatementRaiseStatement = Typed.TypedName (Core.Name "hydra.python.syntax.RaiseStatement")+ -- | DSL injection for the float variant of hydra.python.syntax.RealNumber realNumberFloat :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.RealNumber realNumberFloat x =@@ -7100,6 +7621,10 @@         Core.fieldName = (Core.Name "integer"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.RealNumber+realNumberRealNumber :: Typed.TypedName Syntax.RealNumber+realNumberRealNumber = Typed.TypedName (Core.Name "hydra.python.syntax.RealNumber")+ -- | DSL injection for the dot variant of hydra.python.syntax.RelativeImportPrefix relativeImportPrefixDot :: Typed.TypedTerm Syntax.RelativeImportPrefix relativeImportPrefixDot =@@ -7118,6 +7643,10 @@         Core.fieldName = (Core.Name "ellipsis"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.RelativeImportPrefix+relativeImportPrefixRelativeImportPrefix :: Typed.TypedName Syntax.RelativeImportPrefix+relativeImportPrefixRelativeImportPrefix = Typed.TypedName (Core.Name "hydra.python.syntax.RelativeImportPrefix")+ -- | DSL constructor for the hydra.python.syntax.ReturnStatement wrapper returnStatement :: Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm Syntax.ReturnStatement returnStatement x =@@ -7125,6 +7654,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ReturnStatement"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ReturnStatement+returnStatementReturnStatement :: Typed.TypedName Syntax.ReturnStatement+returnStatementReturnStatement = Typed.TypedName (Core.Name "hydra.python.syntax.ReturnStatement")+ -- | DSL injection for the list variant of hydra.python.syntax.SequencePattern sequencePatternList :: Typed.TypedTerm (Maybe Syntax.MaybeSequencePattern) -> Typed.TypedTerm Syntax.SequencePattern sequencePatternList x =@@ -7134,6 +7667,10 @@         Core.fieldName = (Core.Name "list"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.SequencePattern+sequencePatternSequencePattern :: Typed.TypedName Syntax.SequencePattern+sequencePatternSequencePattern = Typed.TypedName (Core.Name "hydra.python.syntax.SequencePattern")+ -- | DSL injection for the tuple variant of hydra.python.syntax.SequencePattern sequencePatternTuple :: Typed.TypedTerm (Maybe Syntax.OpenSequencePattern) -> Typed.TypedTerm Syntax.SequencePattern sequencePatternTuple x =@@ -7150,6 +7687,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Set"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Set+setSet :: Typed.TypedName Syntax.Set+setSet = Typed.TypedName (Core.Name "hydra.python.syntax.Set")+ -- | DSL constructor for hydra.python.syntax.Setcomp setcomp :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.ForIfClauses -> Typed.TypedTerm Syntax.Setcomp setcomp expression forIfClauses =@@ -7181,6 +7722,10 @@         Core.projectionFieldName = (Core.Name "forIfClauses")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Setcomp+setcompSetcomp :: Typed.TypedName Syntax.Setcomp+setcompSetcomp = Typed.TypedName (Core.Name "hydra.python.syntax.Setcomp")+ -- | DSL updater for the expression field of hydra.python.syntax.Setcomp setcompWithExpression :: Typed.TypedTerm Syntax.Setcomp -> Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Setcomp setcompWithExpression original newVal =@@ -7246,6 +7791,10 @@         Core.projectionFieldName = (Core.Name "rhs")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ShiftExpression+shiftExpressionShiftExpression :: Typed.TypedName Syntax.ShiftExpression+shiftExpressionShiftExpression = Typed.TypedName (Core.Name "hydra.python.syntax.ShiftExpression")+ -- | DSL updater for the lhs field of hydra.python.syntax.ShiftExpression shiftExpressionWithLhs :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm (Maybe Syntax.ShiftLhs) -> Typed.TypedTerm Syntax.ShiftExpression shiftExpressionWithLhs original newVal =@@ -7311,6 +7860,10 @@         Core.projectionFieldName = (Core.Name "operator")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ShiftLhs+shiftLhsShiftLhs :: Typed.TypedName Syntax.ShiftLhs+shiftLhsShiftLhs = Typed.TypedName (Core.Name "hydra.python.syntax.ShiftLhs")+ -- | DSL updater for the operand field of hydra.python.syntax.ShiftLhs shiftLhsWithOperand :: Typed.TypedTerm Syntax.ShiftLhs -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.ShiftLhs shiftLhsWithOperand original newVal =@@ -7363,6 +7916,10 @@         Core.fieldName = (Core.Name "right"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.ShiftOp+shiftOpShiftOp :: Typed.TypedName Syntax.ShiftOp+shiftOpShiftOp = Typed.TypedName (Core.Name "hydra.python.syntax.ShiftOp")+ -- | DSL injection for the number variant of hydra.python.syntax.SignedNumber signedNumberNumber :: Typed.TypedTerm Syntax.Number -> Typed.TypedTerm Syntax.SignedNumber signedNumberNumber x =@@ -7381,6 +7938,10 @@         Core.fieldName = (Core.Name "sign"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.SignedNumber+signedNumberSignedNumber :: Typed.TypedName Syntax.SignedNumber+signedNumberSignedNumber = Typed.TypedName (Core.Name "hydra.python.syntax.SignedNumber")+ -- | DSL injection for the number variant of hydra.python.syntax.SignedRealNumber signedRealNumberNumber :: Typed.TypedTerm Syntax.RealNumber -> Typed.TypedTerm Syntax.SignedRealNumber signedRealNumberNumber x =@@ -7399,6 +7960,10 @@         Core.fieldName = (Core.Name "sign"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.SignedRealNumber+signedRealNumberSignedRealNumber :: Typed.TypedName Syntax.SignedRealNumber+signedRealNumberSignedRealNumber = Typed.TypedName (Core.Name "hydra.python.syntax.SignedRealNumber")+ -- | DSL injection for the assert variant of hydra.python.syntax.SimpleStatement simpleStatementAssert :: Typed.TypedTerm Syntax.AssertStatement -> Typed.TypedTerm Syntax.SimpleStatement simpleStatementAssert x =@@ -7498,6 +8063,10 @@         Core.fieldName = (Core.Name "return"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.SimpleStatement+simpleStatementSimpleStatement :: Typed.TypedName Syntax.SimpleStatement+simpleStatementSimpleStatement = Typed.TypedName (Core.Name "hydra.python.syntax.SimpleStatement")+ -- | DSL injection for the starExpressions variant of hydra.python.syntax.SimpleStatement simpleStatementStarExpressions :: Typed.TypedTerm [Syntax.StarExpression] -> Typed.TypedTerm Syntax.SimpleStatement simpleStatementStarExpressions x =@@ -7568,6 +8137,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.SimpleTypeParameter+simpleTypeParameterSimpleTypeParameter :: Typed.TypedName Syntax.SimpleTypeParameter+simpleTypeParameterSimpleTypeParameter = Typed.TypedName (Core.Name "hydra.python.syntax.SimpleTypeParameter")+ -- | DSL updater for the bound field of hydra.python.syntax.SimpleTypeParameter simpleTypeParameterWithBound :: Typed.TypedTerm Syntax.SimpleTypeParameter -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SimpleTypeParameter simpleTypeParameterWithBound original newVal =@@ -7658,6 +8231,11 @@         Core.fieldName = (Core.Name "primaryAndSlices"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.SingleSubscriptAttributeTarget+singleSubscriptAttributeTargetSingleSubscriptAttributeTarget :: Typed.TypedName Syntax.SingleSubscriptAttributeTarget+singleSubscriptAttributeTargetSingleSubscriptAttributeTarget =+    Typed.TypedName (Core.Name "hydra.python.syntax.SingleSubscriptAttributeTarget")+ -- | DSL injection for the name variant of hydra.python.syntax.SingleTarget singleTargetName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.SingleTarget singleTargetName x =@@ -7676,6 +8254,10 @@         Core.fieldName = (Core.Name "parens"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.SingleTarget+singleTargetSingleTarget :: Typed.TypedName Syntax.SingleTarget+singleTargetSingleTarget = Typed.TypedName (Core.Name "hydra.python.syntax.SingleTarget")+ -- | DSL injection for the subscriptAttributeTarget variant of hydra.python.syntax.SingleTarget singleTargetSubscriptAttributeTarget :: Typed.TypedTerm Syntax.SingleSubscriptAttributeTarget -> Typed.TypedTerm Syntax.SingleTarget singleTargetSubscriptAttributeTarget x =@@ -7738,6 +8320,11 @@         Core.projectionFieldName = (Core.Name "slash")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.SlashNoDefaultParameters+slashNoDefaultParametersSlashNoDefaultParameters :: Typed.TypedName Syntax.SlashNoDefaultParameters+slashNoDefaultParametersSlashNoDefaultParameters =+    Typed.TypedName (Core.Name "hydra.python.syntax.SlashNoDefaultParameters")+ -- | DSL accessor for the starEtc field of hydra.python.syntax.SlashNoDefaultParameters slashNoDefaultParametersStarEtc :: Typed.TypedTerm Syntax.SlashNoDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc) slashNoDefaultParametersStarEtc x =@@ -7871,6 +8458,10 @@           Core.fieldName = (Core.Name "starEtc"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.python.syntax.SlashNoDefault+slashNoDefaultSlashNoDefault :: Typed.TypedName Syntax.SlashNoDefault+slashNoDefaultSlashNoDefault = Typed.TypedName (Core.Name "hydra.python.syntax.SlashNoDefault")+ -- | DSL constructor for hydra.python.syntax.SlashWithDefault slashWithDefault :: Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm [Syntax.ParamWithDefault] -> Typed.TypedTerm Syntax.SlashWithDefault slashWithDefault paramNoDefault paramWithDefault =@@ -7936,6 +8527,11 @@         Core.projectionFieldName = (Core.Name "paramWithDefault")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.SlashWithDefaultParameters+slashWithDefaultParametersSlashWithDefaultParameters :: Typed.TypedName Syntax.SlashWithDefaultParameters+slashWithDefaultParametersSlashWithDefaultParameters =+    Typed.TypedName (Core.Name "hydra.python.syntax.SlashWithDefaultParameters")+ -- | DSL accessor for the starEtc field of hydra.python.syntax.SlashWithDefaultParameters slashWithDefaultParametersStarEtc :: Typed.TypedTerm Syntax.SlashWithDefaultParameters -> Typed.TypedTerm (Maybe Syntax.StarEtc) slashWithDefaultParametersStarEtc x =@@ -8017,6 +8613,10 @@           Core.fieldName = (Core.Name "starEtc"),           Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.python.syntax.SlashWithDefault+slashWithDefaultSlashWithDefault :: Typed.TypedName Syntax.SlashWithDefault+slashWithDefaultSlashWithDefault = Typed.TypedName (Core.Name "hydra.python.syntax.SlashWithDefault")+ -- | DSL updater for the paramNoDefault field of hydra.python.syntax.SlashWithDefault slashWithDefaultWithParamNoDefault :: Typed.TypedTerm Syntax.SlashWithDefault -> Typed.TypedTerm [Syntax.ParamNoDefault] -> Typed.TypedTerm Syntax.SlashWithDefault slashWithDefaultWithParamNoDefault original newVal =@@ -8067,6 +8667,10 @@           Core.fieldName = (Core.Name "step"),           Core.fieldTerm = (Typed.unTypedTerm step)}]})) +-- | DSL name token for hydra.python.syntax.SliceExpression+sliceExpressionSliceExpression :: Typed.TypedName Syntax.SliceExpression+sliceExpressionSliceExpression = Typed.TypedName (Core.Name "hydra.python.syntax.SliceExpression")+ -- | DSL accessor for the start field of hydra.python.syntax.SliceExpression sliceExpressionStart :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm (Maybe Syntax.Expression) sliceExpressionStart x =@@ -8184,6 +8788,11 @@         Core.fieldName = (Core.Name "slice"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.SliceOrStarredExpression+sliceOrStarredExpressionSliceOrStarredExpression :: Typed.TypedName Syntax.SliceOrStarredExpression+sliceOrStarredExpressionSliceOrStarredExpression =+    Typed.TypedName (Core.Name "hydra.python.syntax.SliceOrStarredExpression")+ -- | DSL injection for the starred variant of hydra.python.syntax.SliceOrStarredExpression sliceOrStarredExpressionStarred :: Typed.TypedTerm Syntax.StarredExpression -> Typed.TypedTerm Syntax.SliceOrStarredExpression sliceOrStarredExpressionStarred x =@@ -8193,6 +8802,10 @@         Core.fieldName = (Core.Name "starred"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Slice+sliceSlice :: Typed.TypedName Syntax.Slice+sliceSlice = Typed.TypedName (Core.Name "hydra.python.syntax.Slice")+ -- | DSL injection for the slice_ variant of hydra.python.syntax.Slice sliceSlice_ :: Typed.TypedTerm Syntax.SliceExpression -> Typed.TypedTerm Syntax.Slice sliceSlice_ x =@@ -8224,6 +8837,10 @@         Core.projectionFieldName = (Core.Name "head")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Slices+slicesSlices :: Typed.TypedName Syntax.Slices+slicesSlices = Typed.TypedName (Core.Name "hydra.python.syntax.Slices")+ -- | DSL accessor for the tail field of hydra.python.syntax.Slices slicesTail :: Typed.TypedTerm Syntax.Slices -> Typed.TypedTerm [Syntax.SliceOrStarredExpression] slicesTail x =@@ -8274,6 +8891,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarAnnotation"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.StarAnnotation+starAnnotationStarAnnotation :: Typed.TypedName Syntax.StarAnnotation+starAnnotationStarAnnotation = Typed.TypedName (Core.Name "hydra.python.syntax.StarAnnotation")+ -- | DSL injection for the name variant of hydra.python.syntax.StarAtom starAtomName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.StarAtom starAtomName x =@@ -8283,6 +8904,10 @@         Core.fieldName = (Core.Name "name"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.StarAtom+starAtomStarAtom :: Typed.TypedName Syntax.StarAtom+starAtomStarAtom = Typed.TypedName (Core.Name "hydra.python.syntax.StarAtom")+ -- | DSL injection for the starTargetsListSeq variant of hydra.python.syntax.StarAtom starAtomStarTargetsListSeq :: Typed.TypedTerm (Maybe Syntax.StarTargetsListSeq) -> Typed.TypedTerm Syntax.StarAtom starAtomStarTargetsListSeq x =@@ -8328,6 +8953,10 @@         Core.fieldName = (Core.Name "starComma"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.StarEtc+starEtcStarEtc :: Typed.TypedName Syntax.StarEtc+starEtcStarEtc = Typed.TypedName (Core.Name "hydra.python.syntax.StarEtc")+ -- | DSL injection for the starNoDefault variant of hydra.python.syntax.StarEtc starEtcStarNoDefault :: Typed.TypedTerm Syntax.NoDefaultStarEtc -> Typed.TypedTerm Syntax.StarEtc starEtcStarNoDefault x =@@ -8364,6 +8993,10 @@         Core.fieldName = (Core.Name "star"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.StarExpression+starExpressionStarExpression :: Typed.TypedName Syntax.StarExpression+starExpressionStarExpression = Typed.TypedName (Core.Name "hydra.python.syntax.StarExpression")+ -- | DSL injection for the simple variant of hydra.python.syntax.StarNamedExpression starNamedExpressionSimple :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.StarNamedExpression starNamedExpressionSimple x =@@ -8382,6 +9015,10 @@         Core.fieldName = (Core.Name "star"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.StarNamedExpression+starNamedExpressionStarNamedExpression :: Typed.TypedName Syntax.StarNamedExpression+starNamedExpressionStarNamedExpression = Typed.TypedName (Core.Name "hydra.python.syntax.StarNamedExpression")+ -- | DSL constructor for the hydra.python.syntax.StarNamedExpressions wrapper starNamedExpressions :: Typed.TypedTerm [Syntax.StarNamedExpression] -> Typed.TypedTerm Syntax.StarNamedExpressions starNamedExpressions x =@@ -8389,6 +9026,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarNamedExpressions"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.StarNamedExpressions+starNamedExpressionsStarNamedExpressions :: Typed.TypedName Syntax.StarNamedExpressions+starNamedExpressionsStarNamedExpressions = Typed.TypedName (Core.Name "hydra.python.syntax.StarNamedExpressions")+ -- | DSL injection for the capture variant of hydra.python.syntax.StarPattern starPatternCapture :: Typed.TypedTerm Syntax.PatternCaptureTarget -> Typed.TypedTerm Syntax.StarPattern starPatternCapture x =@@ -8398,6 +9039,10 @@         Core.fieldName = (Core.Name "capture"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.StarPattern+starPatternStarPattern :: Typed.TypedName Syntax.StarPattern+starPatternStarPattern = Typed.TypedName (Core.Name "hydra.python.syntax.StarPattern")+ -- | DSL injection for the wildcard variant of hydra.python.syntax.StarPattern starPatternWildcard :: Typed.TypedTerm Syntax.StarPattern starPatternWildcard =@@ -8407,6 +9052,10 @@         Core.fieldName = (Core.Name "wildcard"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.StarTarget+starTargetStarTarget :: Typed.TypedName Syntax.StarTarget+starTargetStarTarget = Typed.TypedName (Core.Name "hydra.python.syntax.StarTarget")+ -- | DSL injection for the starred variant of hydra.python.syntax.StarTarget starTargetStarred :: Typed.TypedTerm Syntax.StarTarget -> Typed.TypedTerm Syntax.StarTarget starTargetStarred x =@@ -8432,6 +9081,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarTargetsListSeq"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.StarTargetsListSeq+starTargetsListSeqStarTargetsListSeq :: Typed.TypedName Syntax.StarTargetsListSeq+starTargetsListSeqStarTargetsListSeq = Typed.TypedName (Core.Name "hydra.python.syntax.StarTargetsListSeq")+ -- | DSL constructor for the hydra.python.syntax.StarTargetsTupleSeq wrapper starTargetsTupleSeq :: Typed.TypedTerm [Syntax.StarTarget] -> Typed.TypedTerm Syntax.StarTargetsTupleSeq starTargetsTupleSeq x =@@ -8439,6 +9092,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarTargetsTupleSeq"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.StarTargetsTupleSeq+starTargetsTupleSeqStarTargetsTupleSeq :: Typed.TypedName Syntax.StarTargetsTupleSeq+starTargetsTupleSeqStarTargetsTupleSeq = Typed.TypedName (Core.Name "hydra.python.syntax.StarTargetsTupleSeq")+ -- | DSL constructor for hydra.python.syntax.StarTypeParameter starTypeParameter :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.StarExpression) -> Typed.TypedTerm Syntax.StarTypeParameter starTypeParameter name default_ =@@ -8470,6 +9127,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.StarTypeParameter+starTypeParameterStarTypeParameter :: Typed.TypedName Syntax.StarTypeParameter+starTypeParameterStarTypeParameter = Typed.TypedName (Core.Name "hydra.python.syntax.StarTypeParameter")+ -- | DSL updater for the default field of hydra.python.syntax.StarTypeParameter starTypeParameterWithDefault :: Typed.TypedTerm Syntax.StarTypeParameter -> Typed.TypedTerm (Maybe Syntax.StarExpression) -> Typed.TypedTerm Syntax.StarTypeParameter starTypeParameterWithDefault original newVal =@@ -8511,6 +9172,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.StarredExpression"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.StarredExpression+starredExpressionStarredExpression :: Typed.TypedName Syntax.StarredExpression+starredExpressionStarredExpression = Typed.TypedName (Core.Name "hydra.python.syntax.StarredExpression")+ -- | DSL injection for the annotated variant of hydra.python.syntax.Statement statementAnnotated :: Typed.TypedTerm Syntax.AnnotatedStatement -> Typed.TypedTerm Syntax.Statement statementAnnotated x =@@ -8538,6 +9203,10 @@         Core.fieldName = (Core.Name "simple"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.Statement+statementStatement :: Typed.TypedName Syntax.Statement+statementStatement = Typed.TypedName (Core.Name "hydra.python.syntax.Statement")+ -- | DSL constructor for hydra.python.syntax.String string :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Syntax.StringPrefix) -> Typed.TypedTerm Syntax.QuoteStyle -> Typed.TypedTerm Syntax.String_ string value prefix quoteStyle =@@ -8590,6 +9259,10 @@         Core.fieldName = (Core.Name "rawBytes"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.StringPrefix+stringPrefixStringPrefix :: Typed.TypedName Syntax.StringPrefix+stringPrefixStringPrefix = Typed.TypedName (Core.Name "hydra.python.syntax.StringPrefix")+ -- | DSL injection for the unicode variant of hydra.python.syntax.StringPrefix stringPrefixUnicode :: Typed.TypedTerm Syntax.StringPrefix stringPrefixUnicode =@@ -8608,6 +9281,10 @@         Core.projectionFieldName = (Core.Name "quoteStyle")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.String+stringString :: Typed.TypedName Syntax.String_+stringString = Typed.TypedName (Core.Name "hydra.python.syntax.String")+ -- | DSL accessor for the value field of hydra.python.syntax.String stringValue :: Typed.TypedTerm Syntax.String_ -> Typed.TypedTerm String stringValue x =@@ -8698,6 +9375,10 @@         Core.fieldName = (Core.Name "simple"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.SubjectExpression+subjectExpressionSubjectExpression :: Typed.TypedName Syntax.SubjectExpression+subjectExpressionSubjectExpression = Typed.TypedName (Core.Name "hydra.python.syntax.SubjectExpression")+ -- | DSL injection for the tuple variant of hydra.python.syntax.SubjectExpression subjectExpressionTuple :: Typed.TypedTerm [Syntax.StarNamedExpression] -> Typed.TypedTerm Syntax.SubjectExpression subjectExpressionTuple x =@@ -8760,6 +9441,10 @@         Core.projectionFieldName = (Core.Name "operator")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.SumLhs+sumLhsSumLhs :: Typed.TypedName Syntax.SumLhs+sumLhsSumLhs = Typed.TypedName (Core.Name "hydra.python.syntax.SumLhs")+ -- | DSL updater for the operand field of hydra.python.syntax.SumLhs sumLhsWithOperand :: Typed.TypedTerm Syntax.SumLhs -> Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm Syntax.SumLhs sumLhsWithOperand original newVal =@@ -8812,6 +9497,10 @@         Core.fieldName = (Core.Name "sub"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.SumOp+sumOpSumOp :: Typed.TypedName Syntax.SumOp+sumOpSumOp = Typed.TypedName (Core.Name "hydra.python.syntax.SumOp")+ -- | DSL accessor for the rhs field of hydra.python.syntax.Sum sumRhs :: Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm Syntax.Term sumRhs x =@@ -8821,6 +9510,10 @@         Core.projectionFieldName = (Core.Name "rhs")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Sum+sumSum :: Typed.TypedName Syntax.Sum+sumSum = Typed.TypedName (Core.Name "hydra.python.syntax.Sum")+ -- | DSL updater for the lhs field of hydra.python.syntax.Sum sumWithLhs :: Typed.TypedTerm Syntax.Sum -> Typed.TypedTerm (Maybe Syntax.SumLhs) -> Typed.TypedTerm Syntax.Sum sumWithLhs original newVal =@@ -8886,6 +9579,10 @@         Core.projectionFieldName = (Core.Name "primary")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TPrimaryAndArguments+tPrimaryAndArgumentsTPrimaryAndArguments :: Typed.TypedName Syntax.TPrimaryAndArguments+tPrimaryAndArgumentsTPrimaryAndArguments = Typed.TypedName (Core.Name "hydra.python.syntax.TPrimaryAndArguments")+ -- | DSL updater for the arguments field of hydra.python.syntax.TPrimaryAndArguments tPrimaryAndArgumentsWithArguments :: Typed.TypedTerm Syntax.TPrimaryAndArguments -> Typed.TypedTerm (Maybe Syntax.Args) -> Typed.TypedTerm Syntax.TPrimaryAndArguments tPrimaryAndArgumentsWithArguments original newVal =@@ -8951,6 +9648,10 @@         Core.projectionFieldName = (Core.Name "primary")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TPrimaryAndGenexp+tPrimaryAndGenexpTPrimaryAndGenexp :: Typed.TypedName Syntax.TPrimaryAndGenexp+tPrimaryAndGenexpTPrimaryAndGenexp = Typed.TypedName (Core.Name "hydra.python.syntax.TPrimaryAndGenexp")+ -- | DSL updater for the genexp field of hydra.python.syntax.TPrimaryAndGenexp tPrimaryAndGenexpWithGenexp :: Typed.TypedTerm Syntax.TPrimaryAndGenexp -> Typed.TypedTerm Syntax.Genexp -> Typed.TypedTerm Syntax.TPrimaryAndGenexp tPrimaryAndGenexpWithGenexp original newVal =@@ -9016,6 +9717,10 @@         Core.projectionFieldName = (Core.Name "primary")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TPrimaryAndName+tPrimaryAndNameTPrimaryAndName :: Typed.TypedName Syntax.TPrimaryAndName+tPrimaryAndNameTPrimaryAndName = Typed.TypedName (Core.Name "hydra.python.syntax.TPrimaryAndName")+ -- | DSL updater for the name field of hydra.python.syntax.TPrimaryAndName tPrimaryAndNameWithName :: Typed.TypedTerm Syntax.TPrimaryAndName -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TPrimaryAndName tPrimaryAndNameWithName original newVal =@@ -9081,6 +9786,10 @@         Core.projectionFieldName = (Core.Name "slices")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TPrimaryAndSlices+tPrimaryAndSlicesTPrimaryAndSlices :: Typed.TypedName Syntax.TPrimaryAndSlices+tPrimaryAndSlicesTPrimaryAndSlices = Typed.TypedName (Core.Name "hydra.python.syntax.TPrimaryAndSlices")+ -- | DSL updater for the primary field of hydra.python.syntax.TPrimaryAndSlices tPrimaryAndSlicesWithPrimary :: Typed.TypedTerm Syntax.TPrimaryAndSlices -> Typed.TypedTerm Syntax.TPrimary -> Typed.TypedTerm Syntax.TPrimaryAndSlices tPrimaryAndSlicesWithPrimary original newVal =@@ -9160,6 +9869,10 @@         Core.fieldName = (Core.Name "primaryAndSlices"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.TPrimary+tPrimaryTPrimary :: Typed.TypedName Syntax.TPrimary+tPrimaryTPrimary = Typed.TypedName (Core.Name "hydra.python.syntax.TPrimary")+ -- | DSL injection for the atom variant of hydra.python.syntax.TargetWithStarAtom targetWithStarAtomAtom :: Typed.TypedTerm Syntax.StarAtom -> Typed.TypedTerm Syntax.TargetWithStarAtom targetWithStarAtomAtom x =@@ -9187,6 +9900,10 @@         Core.fieldName = (Core.Name "slices"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.TargetWithStarAtom+targetWithStarAtomTargetWithStarAtom :: Typed.TypedName Syntax.TargetWithStarAtom+targetWithStarAtomTargetWithStarAtom = Typed.TypedName (Core.Name "hydra.python.syntax.TargetWithStarAtom")+ -- | DSL constructor for hydra.python.syntax.Term term :: Typed.TypedTerm (Maybe Syntax.TermLhs) -> Typed.TypedTerm Syntax.Factor -> Typed.TypedTerm Syntax.Term term lhs rhs =@@ -9240,6 +9957,10 @@         Core.projectionFieldName = (Core.Name "operator")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TermLhs+termLhsTermLhs :: Typed.TypedName Syntax.TermLhs+termLhsTermLhs = Typed.TypedName (Core.Name "hydra.python.syntax.TermLhs")+ -- | DSL updater for the operand field of hydra.python.syntax.TermLhs termLhsWithOperand :: Typed.TypedTerm Syntax.TermLhs -> Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.TermLhs termLhsWithOperand original newVal =@@ -9319,6 +10040,10 @@         Core.fieldName = (Core.Name "mul"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.python.syntax.TermOp+termOpTermOp :: Typed.TypedName Syntax.TermOp+termOpTermOp = Typed.TypedName (Core.Name "hydra.python.syntax.TermOp")+ -- | DSL accessor for the rhs field of hydra.python.syntax.Term termRhs :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm Syntax.Factor termRhs x =@@ -9328,6 +10053,10 @@         Core.projectionFieldName = (Core.Name "rhs")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Term+termTerm :: Typed.TypedName Syntax.Term+termTerm = Typed.TypedName (Core.Name "hydra.python.syntax.Term")+ -- | DSL updater for the lhs field of hydra.python.syntax.Term termWithLhs :: Typed.TypedTerm Syntax.Term -> Typed.TypedTerm (Maybe Syntax.TermLhs) -> Typed.TypedTerm Syntax.Term termWithLhs original newVal =@@ -9417,6 +10146,10 @@         Core.projectionFieldName = (Core.Name "finally")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TryExceptStarStatement+tryExceptStarStatementTryExceptStarStatement :: Typed.TypedName Syntax.TryExceptStarStatement+tryExceptStarStatementTryExceptStarStatement = Typed.TypedName (Core.Name "hydra.python.syntax.TryExceptStarStatement")+ -- | DSL updater for the body field of hydra.python.syntax.TryExceptStarStatement tryExceptStarStatementWithBody :: Typed.TypedTerm Syntax.TryExceptStarStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryExceptStarStatement tryExceptStarStatementWithBody original newVal =@@ -9596,6 +10329,10 @@         Core.projectionFieldName = (Core.Name "finally")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TryExceptStatement+tryExceptStatementTryExceptStatement :: Typed.TypedName Syntax.TryExceptStatement+tryExceptStatementTryExceptStatement = Typed.TypedName (Core.Name "hydra.python.syntax.TryExceptStatement")+ -- | DSL updater for the body field of hydra.python.syntax.TryExceptStatement tryExceptStatementWithBody :: Typed.TypedTerm Syntax.TryExceptStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryExceptStatement tryExceptStatementWithBody original newVal =@@ -9751,6 +10488,10 @@         Core.projectionFieldName = (Core.Name "finally")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TryFinallyStatement+tryFinallyStatementTryFinallyStatement :: Typed.TypedName Syntax.TryFinallyStatement+tryFinallyStatementTryFinallyStatement = Typed.TypedName (Core.Name "hydra.python.syntax.TryFinallyStatement")+ -- | DSL updater for the body field of hydra.python.syntax.TryFinallyStatement tryFinallyStatementWithBody :: Typed.TypedTerm Syntax.TryFinallyStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryFinallyStatement tryFinallyStatementWithBody original newVal =@@ -9812,6 +10553,10 @@         Core.fieldName = (Core.Name "finally"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.TryStatement+tryStatementTryStatement :: Typed.TypedName Syntax.TryStatement+tryStatementTryStatement = Typed.TypedName (Core.Name "hydra.python.syntax.TryStatement")+ -- | DSL constructor for the hydra.python.syntax.Tuple wrapper tuple :: Typed.TypedTerm [Syntax.StarNamedExpression] -> Typed.TypedTerm Syntax.Tuple tuple x =@@ -9819,6 +10564,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.Tuple"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.Tuple+tupleTuple :: Typed.TypedName Syntax.Tuple+tupleTuple = Typed.TypedName (Core.Name "hydra.python.syntax.Tuple")+ -- | DSL constructor for hydra.python.syntax.TypeAlias typeAlias :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeAlias typeAlias name typeParams expression =@@ -9853,6 +10602,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TypeAlias+typeAliasTypeAlias :: Typed.TypedName Syntax.TypeAlias+typeAliasTypeAlias = Typed.TypedName (Core.Name "hydra.python.syntax.TypeAlias")+ -- | DSL accessor for the typeParams field of hydra.python.syntax.TypeAlias typeAliasTypeParams :: Typed.TypedTerm Syntax.TypeAlias -> Typed.TypedTerm [Syntax.TypeParameter] typeAliasTypeParams x =@@ -9941,6 +10694,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.TypeComment"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TypeComment+typeCommentTypeComment :: Typed.TypedName Syntax.TypeComment+typeCommentTypeComment = Typed.TypedName (Core.Name "hydra.python.syntax.TypeComment")+ -- | DSL injection for the doubleStarredExpression variant of hydra.python.syntax.TypeExpression typeExpressionDoubleStarredExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeExpression typeExpressionDoubleStarredExpression x =@@ -9968,6 +10725,10 @@         Core.fieldName = (Core.Name "starredExpression"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.TypeExpression+typeExpressionTypeExpression :: Typed.TypedName Syntax.TypeExpression+typeExpressionTypeExpression = Typed.TypedName (Core.Name "hydra.python.syntax.TypeExpression")+ -- | DSL injection for the doubleStar variant of hydra.python.syntax.TypeParameter typeParameterDoubleStar :: Typed.TypedTerm Syntax.DoubleStarTypeParameter -> Typed.TypedTerm Syntax.TypeParameter typeParameterDoubleStar x =@@ -9995,6 +10756,10 @@         Core.fieldName = (Core.Name "star"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.TypeParameter+typeParameterTypeParameter :: Typed.TypedName Syntax.TypeParameter+typeParameterTypeParameter = Typed.TypedName (Core.Name "hydra.python.syntax.TypeParameter")+ -- | DSL constructor for hydra.python.syntax.TypedAssignment typedAssignment :: Typed.TypedTerm Syntax.SingleTarget -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.AnnotatedRhs) -> Typed.TypedTerm Syntax.TypedAssignment typedAssignment lhs type_ rhs =@@ -10038,6 +10803,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.TypedAssignment+typedAssignmentTypedAssignment :: Typed.TypedName Syntax.TypedAssignment+typedAssignmentTypedAssignment = Typed.TypedName (Core.Name "hydra.python.syntax.TypedAssignment")+ -- | DSL updater for the lhs field of hydra.python.syntax.TypedAssignment typedAssignmentWithLhs :: Typed.TypedTerm Syntax.TypedAssignment -> Typed.TypedTerm Syntax.SingleTarget -> Typed.TypedTerm Syntax.TypedAssignment typedAssignmentWithLhs original newVal =@@ -10482,6 +11251,10 @@         Core.projectionFieldName = (Core.Name "typeComment")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.UntypedAssignment+untypedAssignmentUntypedAssignment :: Typed.TypedName Syntax.UntypedAssignment+untypedAssignmentUntypedAssignment = Typed.TypedName (Core.Name "hydra.python.syntax.UntypedAssignment")+ -- | DSL updater for the rhs field of hydra.python.syntax.UntypedAssignment untypedAssignmentWithRhs :: Typed.TypedTerm Syntax.UntypedAssignment -> Typed.TypedTerm Syntax.AnnotatedRhs -> Typed.TypedTerm Syntax.UntypedAssignment untypedAssignmentWithRhs original newVal =@@ -10561,6 +11334,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.ValuePattern"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.ValuePattern+valuePatternValuePattern :: Typed.TypedName Syntax.ValuePattern+valuePatternValuePattern = Typed.TypedName (Core.Name "hydra.python.syntax.ValuePattern")+ -- | DSL constructor for hydra.python.syntax.WhileStatement whileStatement :: Typed.TypedTerm Syntax.NamedExpression -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.WhileStatement whileStatement condition body else_ =@@ -10604,6 +11381,10 @@         Core.projectionFieldName = (Core.Name "else")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.python.syntax.WhileStatement+whileStatementWhileStatement :: Typed.TypedName Syntax.WhileStatement+whileStatementWhileStatement = Typed.TypedName (Core.Name "hydra.python.syntax.WhileStatement")+ -- | DSL updater for the body field of hydra.python.syntax.WhileStatement whileStatementWithBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.WhileStatement whileStatementWithBody original newVal =@@ -10741,6 +11522,10 @@               Core.projectionFieldName = (Core.Name "as")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL name token for hydra.python.syntax.WithItem+withItemWithItem :: Typed.TypedName Syntax.WithItem+withItemWithItem = Typed.TypedName (Core.Name "hydra.python.syntax.WithItem")+ -- | DSL constructor for hydra.python.syntax.WithStatement withStatement :: Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.WithItem] -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.WithStatement withStatement async items typeComment body =@@ -10889,6 +11674,10 @@               Core.projectionFieldName = (Core.Name "body")})),             Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL name token for hydra.python.syntax.WithStatement+withStatementWithStatement :: Typed.TypedName Syntax.WithStatement+withStatementWithStatement = Typed.TypedName (Core.Name "hydra.python.syntax.WithStatement")+ -- | DSL updater for the typeComment field of hydra.python.syntax.WithStatement withStatementWithTypeComment :: Typed.TypedTerm Syntax.WithStatement -> Typed.TypedTerm (Maybe Syntax.TypeComment) -> Typed.TypedTerm Syntax.WithStatement withStatementWithTypeComment original newVal =@@ -10938,9 +11727,17 @@         Core.fieldName = (Core.Name "simple"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.python.syntax.YieldExpression+yieldExpressionYieldExpression :: Typed.TypedName Syntax.YieldExpression+yieldExpressionYieldExpression = Typed.TypedName (Core.Name "hydra.python.syntax.YieldExpression")+ -- | DSL constructor for the hydra.python.syntax.YieldStatement wrapper yieldStatement :: Typed.TypedTerm Syntax.YieldExpression -> Typed.TypedTerm Syntax.YieldStatement yieldStatement x =     Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {       Core.wrappedTermTypeName = (Core.Name "hydra.python.syntax.YieldStatement"),       Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.python.syntax.YieldStatement+yieldStatementYieldStatement :: Typed.TypedName Syntax.YieldStatement+yieldStatementYieldStatement = Typed.TypedName (Core.Name "hydra.python.syntax.YieldStatement")

@@ -0,0 +1,576 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.python.utils++module Hydra.Dsl.Python.Utils where++import qualified Hydra.Analysis as Analysis+import qualified Hydra.Ast as Ast+import qualified Hydra.Classes as Classes+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Analysis as DslAnalysis+import qualified Hydra.Dsl.Ast as DslAst+import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Error.Checking as ErrorChecking+import qualified Hydra.Dsl.Error.Core as DslErrorCore+import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging+import qualified Hydra.Dsl.Errors as DslErrors+import qualified Hydra.Dsl.Graph as DslGraph+import qualified Hydra.Dsl.Json.Model as JsonModel+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Dsl.Parsing as DslParsing+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Dsl.Python.Environment as PythonEnvironment+import qualified Hydra.Dsl.Python.Names as PythonNames+import qualified Hydra.Dsl.Python.Syntax as PythonSyntax+import qualified Hydra.Dsl.Query as DslQuery+import qualified Hydra.Dsl.Relational as DslRelational+import qualified Hydra.Dsl.Serialization as DslSerialization+import qualified Hydra.Dsl.Tabular as DslTabular+import qualified Hydra.Dsl.Testing as DslTesting+import qualified Hydra.Dsl.Topology as DslTopology+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Dsl.Validation as DslValidation+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Python.Environment as Environment+import qualified Hydra.Python.Names as Names+import qualified Hydra.Python.Serde as Serde+import qualified Hydra.Python.Syntax as Syntax+import qualified Hydra.Python.Utils as Utils+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Serialization as Serialization+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++-- | DSL reference to hydra.python.utils.annotatedExpression+annotatedExpression :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression+annotatedExpression arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.annotatedExpression")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.annotatedStatement+annotatedStatement :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.Statement+annotatedStatement arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.annotatedStatement")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.assignment+assignment :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.AnnotatedRhs -> Typed.TypedTerm Syntax.Statement+assignment arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.assignment")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.assignmentStatement+assignmentStatement :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement+assignmentStatement arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.assignmentStatement")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.castTo+castTo :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression+castTo arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.castTo")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.commentStatement+commentStatement :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Statement+commentStatement arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.commentStatement")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.decodePyComparisonToPyAwaitPrimary+decodePyComparisonToPyAwaitPrimary :: Typed.TypedTerm Syntax.Comparison -> Typed.TypedTerm (Maybe Syntax.Primary)+decodePyComparisonToPyAwaitPrimary arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.decodePyComparisonToPyAwaitPrimary")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.decodePyConjunctionToPyPrimary+decodePyConjunctionToPyPrimary :: Typed.TypedTerm Syntax.Conjunction -> Typed.TypedTerm (Maybe Syntax.Primary)+decodePyConjunctionToPyPrimary arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.decodePyConjunctionToPyPrimary")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.decodePyExpressionToPyPrimary+decodePyExpressionToPyPrimary :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Primary)+decodePyExpressionToPyPrimary arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.decodePyExpressionToPyPrimary")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.decodePyInversionToPyPrimary+decodePyInversionToPyPrimary :: Typed.TypedTerm Syntax.Inversion -> Typed.TypedTerm (Maybe Syntax.Primary)+decodePyInversionToPyPrimary arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.decodePyInversionToPyPrimary")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.decodePyPowerToPyPrimary+decodePyPowerToPyPrimary :: Typed.TypedTerm Syntax.Power -> Typed.TypedTerm (Maybe Syntax.Primary)+decodePyPowerToPyPrimary arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.decodePyPowerToPyPrimary")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.dottedAssignmentStatement+dottedAssignmentStatement :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement+dottedAssignmentStatement arg0 arg1 arg2 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.dottedAssignmentStatement")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.python.utils.doubleQuotedString+doubleQuotedString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Expression+doubleQuotedString arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.doubleQuotedString")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.findNamespaces+findNamespaces :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName)+findNamespaces arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.findNamespaces")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.functionCall+functionCall :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Expression+functionCall arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.functionCall")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.getItemParams+getItemParams :: Typed.TypedTerm Syntax.Parameters+getItemParams = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.python.utils.getItemParams"))++-- | DSL reference to hydra.python.utils.indentedBlock+indentedBlock :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [[Syntax.Statement]] -> Typed.TypedTerm Syntax.Block+indentedBlock arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.indentedBlock")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.nameAndParams+nameAndParams :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Expression+nameAndParams arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.nameAndParams")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.newtypeStatement+newtypeStatement :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement+newtypeStatement arg0 arg1 arg2 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.newtypeStatement")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.python.utils.orExpression+orExpression :: Typed.TypedTerm [Syntax.Primary] -> Typed.TypedTerm Syntax.Expression+orExpression arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.orExpression")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.primaryAndParams+primaryAndParams :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Expression+primaryAndParams arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.primaryAndParams")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.primaryWithExpressionSlices+primaryWithExpressionSlices :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Primary+primaryWithExpressionSlices arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.primaryWithExpressionSlices")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.primaryWithRhs+primaryWithRhs :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.PrimaryRhs -> Typed.TypedTerm Syntax.Primary+primaryWithRhs arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.primaryWithRhs")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.primaryWithSlices+primaryWithSlices :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.Slice -> Typed.TypedTerm [Syntax.SliceOrStarredExpression] -> Typed.TypedTerm Syntax.Primary+primaryWithSlices arg0 arg1 arg2 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.primaryWithSlices")),+          Core.applicationArgument = (Typed.unTypedTerm arg0)})),+        Core.applicationArgument = (Typed.unTypedTerm arg1)})),+      Core.applicationArgument = (Typed.unTypedTerm arg2)}))++-- | DSL reference to hydra.python.utils.projectFromExpression+projectFromExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Expression+projectFromExpression arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.projectFromExpression")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.pyAssignmentToPyStatement+pyAssignmentToPyStatement :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Statement+pyAssignmentToPyStatement arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyAssignmentToPyStatement")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyAtomToPyExpression+pyAtomToPyExpression :: Typed.TypedTerm Syntax.Atom -> Typed.TypedTerm Syntax.Expression+pyAtomToPyExpression arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyAtomToPyExpression")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyBitwiseOrToPyConjunction+pyBitwiseOrToPyConjunction :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.Conjunction+pyBitwiseOrToPyConjunction arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyBitwiseOrToPyConjunction")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyBitwiseOrToPyExpression+pyBitwiseOrToPyExpression :: Typed.TypedTerm Syntax.BitwiseOr -> Typed.TypedTerm Syntax.Expression+pyBitwiseOrToPyExpression arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyBitwiseOrToPyExpression")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyClassDefinitionToPyStatement+pyClassDefinitionToPyStatement :: Typed.TypedTerm Syntax.ClassDefinition -> Typed.TypedTerm Syntax.Statement+pyClassDefinitionToPyStatement arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyClassDefinitionToPyStatement")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyClosedPatternToPyPatterns+pyClosedPatternToPyPatterns :: Typed.TypedTerm Syntax.ClosedPattern -> Typed.TypedTerm Syntax.Patterns+pyClosedPatternToPyPatterns arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyClosedPatternToPyPatterns")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyConjunctionToPyExpression+pyConjunctionToPyExpression :: Typed.TypedTerm Syntax.Conjunction -> Typed.TypedTerm Syntax.Expression+pyConjunctionToPyExpression arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyConjunctionToPyExpression")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionToBitwiseOr+pyExpressionToBitwiseOr :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.BitwiseOr+pyExpressionToBitwiseOr arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionToBitwiseOr")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionToDisjunction+pyExpressionToDisjunction :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Disjunction+pyExpressionToDisjunction arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionToDisjunction")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionToPyAnnotatedRhs+pyExpressionToPyAnnotatedRhs :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AnnotatedRhs+pyExpressionToPyAnnotatedRhs arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionToPyAnnotatedRhs")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionToPyPrimary+pyExpressionToPyPrimary :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Primary+pyExpressionToPyPrimary arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionToPyPrimary")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionToPySimpleStatement+pyExpressionToPySimpleStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleStatement+pyExpressionToPySimpleStatement arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionToPySimpleStatement")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionToPySlice+pyExpressionToPySlice :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Slice+pyExpressionToPySlice arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionToPySlice")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionToPyStarNamedExpression+pyExpressionToPyStarNamedExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.StarNamedExpression+pyExpressionToPyStarNamedExpression arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionToPyStarNamedExpression")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionToPyStatement+pyExpressionToPyStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement+pyExpressionToPyStatement arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionToPyStatement")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyExpressionsToPyArgs+pyExpressionsToPyArgs :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Args+pyExpressionsToPyArgs arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyExpressionsToPyArgs")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyList+pyList :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.List+pyList arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyList")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyNameToPyExpression+pyNameToPyExpression :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Expression+pyNameToPyExpression arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyNameToPyExpression")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyNameToPyNamedExpression+pyNameToPyNamedExpression :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.NamedExpression+pyNameToPyNamedExpression arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyNameToPyNamedExpression")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyNameToPyPrimary+pyNameToPyPrimary :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Primary+pyNameToPyPrimary arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyNameToPyPrimary")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyNameToPyStarTarget+pyNameToPyStarTarget :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.StarTarget+pyNameToPyStarTarget arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyNameToPyStarTarget")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyNameToPyTypeParameter+pyNameToPyTypeParameter :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TypeParameter+pyNameToPyTypeParameter arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyNameToPyTypeParameter")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyNone+pyNone :: Typed.TypedTerm Syntax.Name+pyNone = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.python.utils.pyNone"))++-- | DSL reference to hydra.python.utils.pyPrimaryToPyBitwiseOr+pyPrimaryToPyBitwiseOr :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.BitwiseOr+pyPrimaryToPyBitwiseOr arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyPrimaryToPyBitwiseOr")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyPrimaryToPyBitwiseXor+pyPrimaryToPyBitwiseXor :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.BitwiseXor+pyPrimaryToPyBitwiseXor arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyPrimaryToPyBitwiseXor")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyPrimaryToPyConjunction+pyPrimaryToPyConjunction :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.Conjunction+pyPrimaryToPyConjunction arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyPrimaryToPyConjunction")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyPrimaryToPyExpression+pyPrimaryToPyExpression :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.Expression+pyPrimaryToPyExpression arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyPrimaryToPyExpression")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pyPrimaryToPySlice+pyPrimaryToPySlice :: Typed.TypedTerm Syntax.Primary -> Typed.TypedTerm Syntax.Slice+pyPrimaryToPySlice arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pyPrimaryToPySlice")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.pySimpleStatementToPyStatement+pySimpleStatementToPyStatement :: Typed.TypedTerm Syntax.SimpleStatement -> Typed.TypedTerm Syntax.Statement+pySimpleStatementToPyStatement arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.pySimpleStatementToPyStatement")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.raiseAssertionError+raiseAssertionError :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Statement+raiseAssertionError arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.raiseAssertionError")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.raiseTypeError+raiseTypeError :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Statement+raiseTypeError arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.raiseTypeError")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.returnSingle+returnSingle :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement+returnSingle arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.returnSingle")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.selfOnlyParams+selfOnlyParams :: Typed.TypedTerm Syntax.Parameters+selfOnlyParams = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.python.utils.selfOnlyParams"))++-- | DSL reference to hydra.python.utils.selfOtherParams+selfOtherParams :: Typed.TypedTerm Syntax.Parameters+selfOtherParams = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.python.utils.selfOtherParams"))++-- | DSL reference to hydra.python.utils.singleQuotedString+singleQuotedString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Expression+singleQuotedString arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.singleQuotedString")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.stringToPyExpression+stringToPyExpression :: Typed.TypedTerm Syntax.QuoteStyle -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.Expression+stringToPyExpression arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.stringToPyExpression")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.python.utils.targetPythonVersion+targetPythonVersion :: Typed.TypedTerm Environment.PythonVersion+targetPythonVersion = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.python.utils.targetPythonVersion"))++-- | DSL reference to hydra.python.utils.tripleQuotedString+tripleQuotedString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Expression+tripleQuotedString arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.tripleQuotedString")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.python.utils.typeAliasStatement+typeAliasStatement :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.TypeParameter] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement+typeAliasStatement arg0 arg1 arg2 arg3 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.typeAliasStatement")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.python.utils.typeAliasStatement310+typeAliasStatement310 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm t0 -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement+typeAliasStatement310 arg0 arg1 arg2 arg3 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.typeAliasStatement310")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.python.utils.unionTypeClassStatements310+unionTypeClassStatements310 :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm [Syntax.Statement]+unionTypeClassStatements310 arg0 arg1 arg2 arg3 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.unionTypeClassStatements310")),+            Core.applicationArgument = (Typed.unTypedTerm arg0)})),+          Core.applicationArgument = (Typed.unTypedTerm arg1)})),+        Core.applicationArgument = (Typed.unTypedTerm arg2)})),+      Core.applicationArgument = (Typed.unTypedTerm arg3)}))++-- | DSL reference to hydra.python.utils.unitVariantMethods+unitVariantMethods :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.Statement]+unitVariantMethods arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.python.utils.unitVariantMethods")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))

@@ -668,23 +668,23 @@ encodeFloatValue :: Core.FloatValue -> Either t0 Syntax.Expression encodeFloatValue fv =     case fv of-      Core.FloatValueFloat32 v0 -> encodeFloatValue_encodeFloat32 v0-      Core.FloatValueFloat64 v0 -> encodeFloatValue_encodeFloat64 v0+      Core.FloatValueFloat32 v0 -> encodeFloatValueEncodeFloat32 v0+      Core.FloatValueFloat64 v0 -> encodeFloatValueEncodeFloat64 v0 -encodeFloatValue_encodeFloat32 :: Float -> Either t0 Syntax.Expression-encodeFloatValue_encodeFloat32 v =+encodeFloatValueEncodeFloat32 :: Float -> Either t0 Syntax.Expression+encodeFloatValueEncodeFloat32 v =        let s = Literals.showFloat32 v-      in (Logic.ifElse (Equality.equal s "NaN") (Right (encodeFloatValue_pySpecialFloat "nan")) (Logic.ifElse (Equality.equal s "Infinity") (Right (encodeFloatValue_pySpecialFloat "inf")) (Logic.ifElse (Equality.equal s "-Infinity") (Right (encodeFloatValue_pySpecialFloat "-inf")) (Right (Utils.pyAtomToPyExpression (Syntax.AtomNumber (Syntax.NumberFloat (Literals.float32ToFloat64 v))))))))+      in (Logic.ifElse (Equality.equal s "NaN") (Right (encodeFloatValuePySpecialFloat "nan")) (Logic.ifElse (Equality.equal s "Infinity") (Right (encodeFloatValuePySpecialFloat "inf")) (Logic.ifElse (Equality.equal s "-Infinity") (Right (encodeFloatValuePySpecialFloat "-inf")) (Right (Utils.pyAtomToPyExpression (Syntax.AtomNumber (Syntax.NumberFloat (Literals.float32ToFloat64 v)))))))) -encodeFloatValue_encodeFloat64 :: Double -> Either t0 Syntax.Expression-encodeFloatValue_encodeFloat64 v =+encodeFloatValueEncodeFloat64 :: Double -> Either t0 Syntax.Expression+encodeFloatValueEncodeFloat64 v =        let s = Literals.showFloat64 v-      in (Logic.ifElse (Equality.equal s "NaN") (Right (encodeFloatValue_pySpecialFloat "nan")) (Logic.ifElse (Equality.equal s "Infinity") (Right (encodeFloatValue_pySpecialFloat "inf")) (Logic.ifElse (Equality.equal s "-Infinity") (Right (encodeFloatValue_pySpecialFloat "-inf")) (Logic.ifElse (Equality.equal s "-0.0") (Right (encodeFloatValue_pySpecialFloat "-0.0")) (Right (Utils.pyAtomToPyExpression (Syntax.AtomNumber (Syntax.NumberFloat v))))))))+      in (Logic.ifElse (Equality.equal s "NaN") (Right (encodeFloatValuePySpecialFloat "nan")) (Logic.ifElse (Equality.equal s "Infinity") (Right (encodeFloatValuePySpecialFloat "inf")) (Logic.ifElse (Equality.equal s "-Infinity") (Right (encodeFloatValuePySpecialFloat "-inf")) (Logic.ifElse (Equality.equal s "-0.0") (Right (encodeFloatValuePySpecialFloat "-0.0")) (Right (Utils.pyAtomToPyExpression (Syntax.AtomNumber (Syntax.NumberFloat v)))))))) -encodeFloatValue_pySpecialFloat :: String -> Syntax.Expression-encodeFloatValue_pySpecialFloat value =+encodeFloatValuePySpecialFloat :: String -> Syntax.Expression+encodeFloatValuePySpecialFloat value =     Utils.functionCall (Utils.pyNameToPyPrimary (Syntax.Name "float")) [       Utils.singleQuotedString value] 

@@ -0,0 +1,19 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Build configuration for PEP 621 (pyproject.toml) Python distribution packages.++module Hydra.Python.Pyproject where++import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++data PyProjectBuildConfiguration =+  PyProjectBuildConfiguration {+    pyProjectBuildConfigurationDependencies :: [Packaging.PackageDependency]}+  deriving (Eq, Ord, Read, Show)++_PyProjectBuildConfiguration = Core.Name "hydra.python.pyproject.PyProjectBuildConfiguration"++_PyProjectBuildConfiguration_dependencies = Core.Name "dependencies"