diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -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 diff --git a/hydra-python.cabal b/hydra-python.cabal --- a/hydra-python.cabal +++ b/hydra-python.cabal @@ -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 diff --git a/src/main/haskell/Hydra/Dsl/Python/Environment.hs b/src/main/haskell/Hydra/Dsl/Python/Environment.hs --- a/src/main/haskell/Hydra/Dsl/Python/Environment.hs +++ b/src/main/haskell/Hydra/Dsl/Python/Environment.hs @@ -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") diff --git a/src/main/haskell/Hydra/Dsl/Python/Names.hs b/src/main/haskell/Hydra/Dsl/Python/Names.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Python/Names.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Python/Syntax.hs b/src/main/haskell/Hydra/Dsl/Python/Syntax.hs --- a/src/main/haskell/Hydra/Dsl/Python/Syntax.hs +++ b/src/main/haskell/Hydra/Dsl/Python/Syntax.hs @@ -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") diff --git a/src/main/haskell/Hydra/Dsl/Python/Utils.hs b/src/main/haskell/Hydra/Dsl/Python/Utils.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Python/Utils.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Python/Coder.hs b/src/main/haskell/Hydra/Python/Coder.hs --- a/src/main/haskell/Hydra/Python/Coder.hs +++ b/src/main/haskell/Hydra/Python/Coder.hs @@ -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] diff --git a/src/main/haskell/Hydra/Python/Pyproject.hs b/src/main/haskell/Hydra/Python/Pyproject.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Python/Pyproject.hs @@ -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"