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-kernel.cabal b/hydra-kernel.cabal --- a/hydra-kernel.cabal +++ b/hydra-kernel.cabal @@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: hydra-kernel -version: 0.17.0 +version: 0.17.1 synopsis: The Hydra kernel: core types, terms, inference, and DSL runtime 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". This package is the Hydra kernel: the core type and term model, type inference, the term rewriting and reduction engine, the primitive library, and the DSL runtime — the code that must be present in every Hydra implementation. The convenient entry point is the Hydra.Kernel module, which re-exports the kernel's collision-free surface. category: Data @@ -70,20 +70,39 @@ Hydra.Dependencies Hydra.Differentiation Hydra.Docs + Hydra.Dsl.Analysis + Hydra.Dsl.Annotations + Hydra.Dsl.Arity Hydra.Dsl.Ast + Hydra.Dsl.Checking Hydra.Dsl.Coders + Hydra.Dsl.Constants Hydra.Dsl.Core + Hydra.Dsl.Dependencies Hydra.Dsl.Docs + Hydra.Dsl.Environment Hydra.Dsl.Error.Checking Hydra.Dsl.Error.Core Hydra.Dsl.Error.File Hydra.Dsl.Error.Packaging Hydra.Dsl.Error.System Hydra.Dsl.Errors + Hydra.Dsl.Extract.Json Hydra.Dsl.File + Hydra.Dsl.Formatting Hydra.Dsl.Graph + Hydra.Dsl.Json.Bootstrap + Hydra.Dsl.Json.Decode + Hydra.Dsl.Json.Decoding + Hydra.Dsl.Json.Encode Hydra.Dsl.Json.Model + Hydra.Dsl.Json.Parser + Hydra.Dsl.Json.Writer + Hydra.Dsl.Json.Yaml.Decode + Hydra.Dsl.Json.Yaml.Encode + Hydra.Dsl.Lexical Hydra.Dsl.Lib.Chars + Hydra.Dsl.Lib.Defaults Hydra.Dsl.Lib.Eithers Hydra.Dsl.Lib.Equality Hydra.Dsl.Lib.Lists @@ -96,19 +115,33 @@ Hydra.Dsl.Lib.Regex Hydra.Dsl.Lib.Sets Hydra.Dsl.Lib.Strings + Hydra.Dsl.Names Hydra.Dsl.Packaging Hydra.Dsl.Parsing Hydra.Dsl.Paths + Hydra.Dsl.Predicates Hydra.Dsl.Query + Hydra.Dsl.Reduction + Hydra.Dsl.Refs Hydra.Dsl.Relational + Hydra.Dsl.Resolution + Hydra.Dsl.Rewriting + Hydra.Dsl.Scoping + Hydra.Dsl.Serialization + Hydra.Dsl.Show.Docs + Hydra.Dsl.Sorting + Hydra.Dsl.Strip Hydra.Dsl.System Hydra.Dsl.Tabular + Hydra.Dsl.Test.Transform + Hydra.Dsl.Test.Utils Hydra.Dsl.Testing Hydra.Dsl.Time Hydra.Dsl.Topology Hydra.Dsl.Typing Hydra.Dsl.Util Hydra.Dsl.Validation + Hydra.Dsl.Variables Hydra.Dsl.Variants Hydra.Dsl.Yaml.Model Hydra.Dsls @@ -169,10 +202,12 @@ Hydra.Languages Hydra.Lexical Hydra.Lib.Chars + Hydra.Lib.Defaults Hydra.Lib.Effects Hydra.Lib.Eithers Hydra.Lib.Equality Hydra.Lib.Files + Hydra.Lib.Hashing Hydra.Lib.Lists Hydra.Lib.Literals Hydra.Lib.Logic @@ -215,6 +250,7 @@ Hydra.Overlay.Haskell.Lib.Eithers Hydra.Overlay.Haskell.Lib.Equality Hydra.Overlay.Haskell.Lib.Files + Hydra.Overlay.Haskell.Lib.Hashing Hydra.Overlay.Haskell.Lib.Lists Hydra.Overlay.Haskell.Lib.Literals Hydra.Overlay.Haskell.Lib.Logic @@ -237,6 +273,7 @@ Hydra.Read.Docs Hydra.Reduction Hydra.Reflect + Hydra.Refs Hydra.Relational Hydra.Resolution Hydra.Rewriting @@ -279,7 +316,8 @@ hs-source-dirs: src/main/haskell build-depends: - base >=4.19.0 && <4.22 + SHA >=1.6.4 && <1.7 + , base >=4.19.0 && <4.22 , base64-bytestring >=1.2.1 && <1.3 , bytestring >=0.11.5 && <0.13 , containers >=0.6.7 && <0.8 diff --git a/src/main/haskell/Hydra/Codegen.hs b/src/main/haskell/Hydra/Codegen.hs --- a/src/main/haskell/Hydra/Codegen.hs +++ b/src/main/haskell/Hydra/Codegen.hs @@ -304,7 +304,47 @@ _ -> Nothing) (Packaging.moduleDefinitions m))) kernelModules) in (Eithers.bind (Inference.inferGraphTypes cx dataElements g0) (\inferResultWithCx -> let g1 = Pairs.first (Pairs.first inferResultWithCx) - in (generateLexicon g1))) + schemaElements = + Lists.concat (Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of + Packaging.DefinitionType v0 -> Just ((\name -> \typ -> + let schemaTerm = Core.TermVariable (Core.Name "hydra.core.Type") + dataTerm = + Annotations.normalizeTermAnnotations (Core.TermAnnotated (Core.AnnotatedTerm { + Core.annotatedTermBody = (EncodeCore.type_ typ), + Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.fromList [ + (Constants.keyType, schemaTerm)]))})) + in Core.Binding { + Core.bindingName = name, + Core.bindingTerm = dataTerm, + Core.bindingTypeScheme = (Just (Core.TypeScheme { + Core.typeSchemeVariables = [], + Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), + Core.typeSchemeConstraints = Nothing}))}) (Packaging.typeDefinitionName v0) (Core.typeSchemeBody (Packaging.typeDefinitionBody v0))) + _ -> Nothing) (Packaging.moduleDefinitions m))) kernelModules) + typeBoundTerms = Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) schemaElements) + typeBoundTypes = + Maps.fromList (Optionals.cat (Lists.map (\b -> Optionals.map (\ts -> (Core.bindingName b, ts)) (Core.bindingTypeScheme b)) schemaElements)) + g2 = + Graph.Graph { + Graph.graphBoundTerms = (Maps.union typeBoundTerms (Graph.graphBoundTerms g1)), + Graph.graphBoundTypes = (Graph.graphBoundTypes g1), + Graph.graphClassConstraints = (Graph.graphClassConstraints g1), + Graph.graphLambdaVariables = (Graph.graphLambdaVariables g1), + Graph.graphMetadata = (Graph.graphMetadata g1), + Graph.graphPrimitives = (Graph.graphPrimitives g1), + Graph.graphSchemaTypes = (Graph.graphSchemaTypes g1), + Graph.graphTypeVariables = (Graph.graphTypeVariables g1)} + g3 = + Graph.Graph { + Graph.graphBoundTerms = (Graph.graphBoundTerms g2), + Graph.graphBoundTypes = (Maps.union typeBoundTypes (Graph.graphBoundTypes g2)), + Graph.graphClassConstraints = (Graph.graphClassConstraints g2), + Graph.graphLambdaVariables = (Graph.graphLambdaVariables g2), + Graph.graphMetadata = (Graph.graphMetadata g2), + Graph.graphPrimitives = (Graph.graphPrimitives g2), + Graph.graphSchemaTypes = (Graph.graphSchemaTypes g2), + Graph.graphTypeVariables = (Graph.graphTypeVariables g2)} + in (generateLexicon g3))) -- | Perform type inference on modules and reconstruct with inferred types inferModules :: Typing.InferenceContext -> Graph.Graph -> [Packaging.Module] -> [Packaging.Module] -> Either Errors.Error [Packaging.Module] diff --git a/src/main/haskell/Hydra/Decode/Error/Packaging.hs b/src/main/haskell/Hydra/Decode/Error/Packaging.hs --- a/src/main/haskell/Hydra/Decode/Error/Packaging.hs +++ b/src/main/haskell/Hydra/Decode/Error/Packaging.hs @@ -170,7 +170,10 @@ (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidModule t) (invalidModuleError cx input))), ( Core.Name "invalidPackageName", - (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidPackageName t) (invalidPackageNameError cx input)))] + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorInvalidPackageName t) (invalidPackageNameError cx input))), + ( + Core.Name "undeclaredDependency", + (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorUndeclaredDependency t) (undeclaredDependencyError cx input)))] in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.cat [ "no such field ", (Core.unName fname), @@ -197,3 +200,15 @@ ErrorPackaging.missingDocumentationErrorModuleName = field_moduleName, ErrorPackaging.missingDocumentationErrorName = field_name})))) _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.MissingDocumentationError")) (ExtractCore.stripWithDecodingError cx raw) + +-- | Decoder for hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorPackaging.UndeclaredDependencyError +undeclaredDependencyError cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermRecord v0 -> + let fieldMap = ExtractCore.toFieldMap v0 + in (Eithers.bind (ExtractCore.requireField "moduleName" DecodePackaging.moduleName fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "referencedName" DecodeCore.name fieldMap cx) (\field_referencedName -> Eithers.bind (ExtractCore.requireField "owningModuleName" DecodePackaging.moduleName fieldMap cx) (\field_owningModuleName -> Right (ErrorPackaging.UndeclaredDependencyError { + ErrorPackaging.undeclaredDependencyErrorModuleName = field_moduleName, + ErrorPackaging.undeclaredDependencyErrorReferencedName = field_referencedName, + ErrorPackaging.undeclaredDependencyErrorOwningModuleName = field_owningModuleName}))))) + _ -> Left (Errors.DecodingError "expected a record of type hydra.error.packaging.UndeclaredDependencyError")) (ExtractCore.stripWithDecodingError cx raw) diff --git a/src/main/haskell/Hydra/Decode/Typed.hs b/src/main/haskell/Hydra/Decode/Typed.hs --- a/src/main/haskell/Hydra/Decode/Typed.hs +++ b/src/main/haskell/Hydra/Decode/Typed.hs @@ -28,6 +28,13 @@ Typed.typedBindingTerm = field_term})))) _ -> Left (Errors.DecodingError "expected a record of type hydra.typed.TypedBinding")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.typed.TypedName +typedName :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedName a) +typedName a cx raw = + Eithers.either (\err -> Left err) (\stripped -> case stripped of + Core.TermWrap v0 -> Eithers.map (\b -> Typed.TypedName b) (DecodeCore.name cx (Core.wrappedTermBody v0)) + _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) + -- | Decoder for hydra.typed.TypedTerm typedTerm :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedTerm a) typedTerm a cx raw = diff --git a/src/main/haskell/Hydra/Decoding.hs b/src/main/haskell/Hydra/Decoding.hs --- a/src/main/haskell/Hydra/Decoding.hs +++ b/src/main/haskell/Hydra/Decoding.hs @@ -29,7 +29,6 @@ import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Names as Names import qualified Hydra.Packaging as Packaging @@ -126,17 +125,10 @@ -- | Generate a binding name for a decoder function from a type name decodeBindingName :: Core.Name -> Core.Name -decodeBindingName n = - - let parts = Strings.splitOn "." (Core.unName n) - localPart = Formatting.decapitalize (Names.localNameOf n) - localResult = Core.Name localPart - in (Optionals.cases (Lists.maybeInit parts) localResult (\nsParts -> Optionals.cases (Lists.uncons nsParts) localResult (\nsUc -> - let tail = Pairs.second nsUc - in (Core.Name (Strings.intercalate "." (Lists.concat2 [ - "hydra", - "decode"] (Lists.concat2 tail [ - localPart]))))))) +decodeBindingName = + Names.derivedBindingName [ + "hydra", + "decode"] True -- | Generate a decoder for an Either type decodeEitherType :: Core.EitherType -> Core.Term @@ -1552,13 +1544,10 @@ -- | Generate a decoder module name from a source module name decodeModuleName :: Packaging.ModuleName -> Packaging.ModuleName -decodeModuleName ns = - - let parts = Strings.splitOn "." (Packaging.unModuleName ns) - fallback = Packaging.ModuleName (Packaging.unModuleName ns) - in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.cat [ - "hydra.decode.", - (Strings.intercalate "." (Pairs.second uc))]))) +decodeModuleName = + Names.derivedModuleName [ + "hydra", + "decode"] True -- | Generate a decoder for a pair type decodePairType :: Core.PairType -> Core.Term diff --git a/src/main/haskell/Hydra/Dependencies.hs b/src/main/haskell/Hydra/Dependencies.hs --- a/src/main/haskell/Hydra/Dependencies.hs +++ b/src/main/haskell/Hydra/Dependencies.hs @@ -4,8 +4,10 @@ module Hydra.Dependencies where +import qualified Hydra.Annotations as Annotations import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders +import qualified Hydra.Constants as Constants import qualified Hydra.Core as Core import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking @@ -311,10 +313,7 @@ let bindings = Maps.toList bindingMap keys = Sets.fromList (Lists.map Pairs.first bindings) - hasTypeAnnotation = - \term -> case term of - Core.TermAnnotated v0 -> hasTypeAnnotation (Core.annotatedTermBody v0) - _ -> False + hasTypeAnnotation = \term -> Optionals.isGiven (Annotations.getTermAnnotation Constants.keyType term) depsOf = \nameAndTerm -> let name = Pairs.first nameAndTerm diff --git a/src/main/haskell/Hydra/Dsl/Analysis.hs b/src/main/haskell/Hydra/Dsl/Analysis.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Analysis.hs @@ -0,0 +1,307 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.analysis + +module Hydra.Dsl.Analysis where + +import qualified Hydra.Analysis as Analysis +import qualified Hydra.Annotations as Annotations +import qualified Hydra.Arity as Arity +import qualified Hydra.Ast as Ast +import qualified Hydra.Checking as Checking +import qualified Hydra.Coders as Coders +import qualified Hydra.Constants as Constants +import qualified Hydra.Core as Core +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Dependencies as Dependencies +import qualified Hydra.Docs as Docs +import qualified Hydra.Dsl.Annotations as DslAnnotations +import qualified Hydra.Dsl.Arity as DslArity +import qualified Hydra.Dsl.Ast as DslAst +import qualified Hydra.Dsl.Checking as DslChecking +import qualified Hydra.Dsl.Coders as DslCoders +import qualified Hydra.Dsl.Constants as DslConstants +import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Dsl.Dependencies as DslDependencies +import qualified Hydra.Dsl.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as DslErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Lexical as DslLexical +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.Predicates as DslPredicates +import qualified Hydra.Dsl.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Rewriting as DslRewriting +import qualified Hydra.Dsl.Scoping as DslScoping +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Variables as DslVariables +import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Error.Checking as ErrorChecking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Names as Names +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Predicates as Predicates +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Scoping as Scoping +import qualified Hydra.Strip as Strip +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variables as Variables +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Set as S + +-- | DSL reference to hydra.analysis.addNamesToModuleNames +addNamesToModuleNames :: Typed.TypedTerm (Packaging.ModuleName -> t0) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (Util.ModuleNames t0) -> Typed.TypedTerm (Util.ModuleNames t0) +addNamesToModuleNames 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.analysis.addNamesToModuleNames")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.analysis.analyzeFunctionTerm +analyzeFunctionTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t0) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 (Typing.FunctionStructure t0)) +analyzeFunctionTerm arg0 arg1 arg2 arg3 arg4 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.analyzeFunctionTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})) + +-- | DSL reference to hydra.analysis.analyzeFunctionTermWith +analyzeFunctionTermWith :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t0) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 (Typing.FunctionStructure t0)) +analyzeFunctionTermWith arg0 arg1 arg2 arg3 arg4 arg5 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.analyzeFunctionTermWith")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})), + Core.applicationArgument = (Typed.unTypedTerm arg5)})) + +-- | DSL reference to hydra.analysis.analyzeFunctionTermWithFinish +analyzeFunctionTermWithFinish :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm t0 -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 (Typing.FunctionStructure t0)) +analyzeFunctionTermWithFinish arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (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.analysis.analyzeFunctionTermWithFinish")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})), + Core.applicationArgument = (Typed.unTypedTerm arg5)})), + Core.applicationArgument = (Typed.unTypedTerm arg6)})), + Core.applicationArgument = (Typed.unTypedTerm arg7)})), + Core.applicationArgument = (Typed.unTypedTerm arg8)})) + +-- | DSL reference to hydra.analysis.analyzeFunctionTermWithGather +analyzeFunctionTermWithGather :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t0) -> Typed.TypedTerm Bool -> Typed.TypedTerm t0 -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 (Typing.FunctionStructure t0)) +analyzeFunctionTermWithGather arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10 arg11 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.analyzeFunctionTermWithGather")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})), + Core.applicationArgument = (Typed.unTypedTerm arg5)})), + Core.applicationArgument = (Typed.unTypedTerm arg6)})), + Core.applicationArgument = (Typed.unTypedTerm arg7)})), + Core.applicationArgument = (Typed.unTypedTerm arg8)})), + Core.applicationArgument = (Typed.unTypedTerm arg9)})), + Core.applicationArgument = (Typed.unTypedTerm arg10)})), + Core.applicationArgument = (Typed.unTypedTerm arg11)})) + +-- | DSL reference to hydra.analysis.definitionDependencyModuleNames +definitionDependencyModuleNames :: Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm (S.Set Packaging.ModuleName) +definitionDependencyModuleNames arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.definitionDependencyModuleNames")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.analysis.dependencyModuleNames +dependencyModuleNames :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Either Errors.Error (S.Set Packaging.ModuleName)) +dependencyModuleNames arg0 arg1 arg2 arg3 arg4 arg5 arg6 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.dependencyModuleNames")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})), + Core.applicationArgument = (Typed.unTypedTerm arg5)})), + Core.applicationArgument = (Typed.unTypedTerm arg6)})) + +-- | DSL reference to hydra.analysis.gatherApplications +gatherApplications :: Typed.TypedTerm Core.Term -> Typed.TypedTerm ([Core.Term], Core.Term) +gatherApplications arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.gatherApplications")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.analysis.gatherArgs +gatherArgs :: Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Term] -> Typed.TypedTerm (Core.Term, [Core.Term]) +gatherArgs arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.gatherArgs")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.analysis.gatherArgsWithTypeApps +gatherArgsWithTypeApps :: Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Term] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Core.Term, ([Core.Term], [Core.Type])) +gatherArgsWithTypeApps 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.analysis.gatherArgsWithTypeApps")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.analysis.isSelfTailRecursive +isSelfTailRecursive :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isSelfTailRecursive arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.isSelfTailRecursive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.analysis.isSimpleAssignment +isSimpleAssignment :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isSimpleAssignment arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.isSimpleAssignment")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.analysis.isTailRecursiveInTailPosition +isTailRecursiveInTailPosition :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isTailRecursiveInTailPosition arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.isTailRecursiveInTailPosition")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.analysis.moduleContainsBinaryLiterals +moduleContainsBinaryLiterals :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Bool +moduleContainsBinaryLiterals arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.moduleContainsBinaryLiterals")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.analysis.moduleContainsDecimalLiterals +moduleContainsDecimalLiterals :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Bool +moduleContainsDecimalLiterals arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.moduleContainsDecimalLiterals")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.analysis.moduleDependencyModuleNames +moduleDependencyModuleNames :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Packaging.Module -> Typed.TypedTerm (Either Errors.Error (S.Set Packaging.ModuleName)) +moduleDependencyModuleNames arg0 arg1 arg2 arg3 arg4 arg5 arg6 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.analysis.moduleDependencyModuleNames")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})), + Core.applicationArgument = (Typed.unTypedTerm arg5)})), + Core.applicationArgument = (Typed.unTypedTerm arg6)})) + +-- | DSL reference to hydra.analysis.moduleNamesForDefinitions +moduleNamesForDefinitions :: Typed.TypedTerm (Packaging.ModuleName -> t0) -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm (Util.ModuleNames t0) +moduleNamesForDefinitions 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.analysis.moduleNamesForDefinitions")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) diff --git a/src/main/haskell/Hydra/Dsl/Annotations.hs b/src/main/haskell/Hydra/Dsl/Annotations.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Annotations.hs @@ -0,0 +1,324 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.annotations + +module Hydra.Dsl.Annotations where + +import qualified Hydra.Annotations as Annotations +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Constants as Constants +import qualified Hydra.Core as Core +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Docs as Docs +import qualified Hydra.Dsl.Ast as DslAst +import qualified Hydra.Dsl.Coders as DslCoders +import qualified Hydra.Dsl.Constants as DslConstants +import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Dsl.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Lexical as DslLexical +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Encode.Core as EncodeCore +import qualified Hydra.Error.Checking as Checking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Show.Core as ShowCore +import qualified Hydra.Show.Errors as ShowErrors +import qualified Hydra.Strip as Strip +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL reference to hydra.annotations.aggregateAnnotations +aggregateAnnotations :: Ord t2 => (Typed.TypedTerm (t0 -> Maybe t1) -> Typed.TypedTerm (t1 -> t0) -> Typed.TypedTerm (t1 -> M.Map t2 t3) -> Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map t2 t3)) +aggregateAnnotations 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.annotations.aggregateAnnotations")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.annotations.commentsFromBinding +commentsFromBinding :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm (Either Errors.Error (Maybe String)) +commentsFromBinding 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.annotations.commentsFromBinding")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.commentsFromFieldType +commentsFromFieldType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.FieldType -> Typed.TypedTerm (Either Errors.Error (Maybe String)) +commentsFromFieldType 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.annotations.commentsFromFieldType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.getAnnotationMap +getAnnotationMap :: Typed.TypedTerm Core.Term -> Typed.TypedTerm (M.Map Core.Name Core.Term) +getAnnotationMap arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.getAnnotationMap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.annotations.getDescription +getDescription :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (Either Errors.Error (Maybe String)) +getDescription 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.annotations.getDescription")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.getTermAnnotation +getTermAnnotation :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Maybe Core.Term) +getTermAnnotation arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.getTermAnnotation")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.annotations.getTermDescription +getTermDescription :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error (Maybe String)) +getTermDescription 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.annotations.getTermDescription")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.getType +getType :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (Either Errors.DecodingError (Maybe Core.Type)) +getType arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.getType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.annotations.getTypeAnnotation +getTypeAnnotation :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Maybe Core.Term) +getTypeAnnotation arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.getTypeAnnotation")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.annotations.getTypeClasses +getTypeClasses :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error (M.Map Core.Name (S.Set Core.Name))) +getTypeClasses 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.annotations.getTypeClasses")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.getTypeDescription +getTypeDescription :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error (Maybe String)) +getTypeDescription 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.annotations.getTypeDescription")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.hasDescription +hasDescription :: Typed.TypedTerm (M.Map Core.Name t0) -> Typed.TypedTerm Bool +hasDescription arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.hasDescription")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.annotations.hasTypeDescription +hasTypeDescription :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +hasTypeDescription arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.hasTypeDescription")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.annotations.isNativeType +isNativeType :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Bool +isNativeType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.isNativeType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.annotations.normalizeTermAnnotations +normalizeTermAnnotations :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +normalizeTermAnnotations arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.normalizeTermAnnotations")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.annotations.normalizeTypeAnnotations +normalizeTypeAnnotations :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +normalizeTypeAnnotations arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.normalizeTypeAnnotations")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.annotations.setAnnotation +setAnnotation :: Ord t0 => (Typed.TypedTerm t0 -> Typed.TypedTerm (Maybe t1) -> Typed.TypedTerm (M.Map t0 t1) -> Typed.TypedTerm (M.Map t0 t1)) +setAnnotation 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.annotations.setAnnotation")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.setDescription +setDescription :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Core.Term) +setDescription arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setDescription")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.annotations.setTermAnnotation +setTermAnnotation :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +setTermAnnotation 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.annotations.setTermAnnotation")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.setTermDescription +setTermDescription :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +setTermDescription arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setTermDescription")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.annotations.setType +setType :: Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Core.Term) +setType arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.annotations.setTypeAnnotation +setTypeAnnotation :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +setTypeAnnotation 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.annotations.setTypeAnnotation")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.annotations.setTypeClasses +setTypeClasses :: Typed.TypedTerm (M.Map Core.Name (S.Set Core.Name)) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +setTypeClasses arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setTypeClasses")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.annotations.setTypeDescription +setTypeDescription :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +setTypeDescription arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.setTypeDescription")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.annotations.termAnnotationInternal +termAnnotationInternal :: Typed.TypedTerm Core.Term -> Typed.TypedTerm (M.Map Core.Name Core.Term) +termAnnotationInternal arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.termAnnotationInternal")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.annotations.typeAnnotationInternal +typeAnnotationInternal :: Typed.TypedTerm Core.Type -> Typed.TypedTerm (M.Map Core.Name Core.Term) +typeAnnotationInternal arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.typeAnnotationInternal")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.annotations.wrapAnnotationMap +wrapAnnotationMap :: Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm Core.Term +wrapAnnotationMap arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.annotations.wrapAnnotationMap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Arity.hs b/src/main/haskell/Hydra/Dsl/Arity.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Arity.hs @@ -0,0 +1,99 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.arity + +module Hydra.Dsl.Arity where + +import qualified Hydra.Arity as Arity +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.arity.primitiveArity +primitiveArity :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm Int +primitiveArity arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.primitiveArity")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.arity.termArity +termArity :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Int +termArity arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.termArity")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.arity.typeArity +typeArity :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Int +typeArity arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.typeArity")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.arity.typeSchemeArity +typeSchemeArity :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Int +typeSchemeArity arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.typeSchemeArity")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.arity.uncurryType +uncurryType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Core.Type] +uncurryType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.arity.uncurryType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Ast.hs b/src/main/haskell/Hydra/Dsl/Ast.hs --- a/src/main/haskell/Hydra/Dsl/Ast.hs +++ b/src/main/haskell/Hydra/Dsl/Ast.hs @@ -6,11 +6,17 @@ import qualified Hydra.Ast as Ast import qualified Hydra.Core as Core +import qualified Hydra.Decode.Ast as DecodeAst import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Ast as EncodeAst import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL name token for hydra.ast.Associativity +associativityAssociativity :: Typed.TypedName Ast.Associativity +associativityAssociativity = Typed.TypedName (Core.Name "hydra.ast.Associativity") + -- | DSL injection for the both variant of hydra.ast.Associativity associativityBoth :: Typed.TypedTerm Ast.Associativity associativityBoth = @@ -63,6 +69,10 @@ Core.fieldName = (Core.Name "newlineAfterContent"), Core.fieldTerm = (Typed.unTypedTerm newlineAfterContent)}]})) +-- | DSL name token for hydra.ast.BlockStyle +blockStyleBlockStyle :: Typed.TypedName Ast.BlockStyle +blockStyleBlockStyle = Typed.TypedName (Core.Name "hydra.ast.BlockStyle") + -- | DSL accessor for the indent field of hydra.ast.BlockStyle blockStyleIndent :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm (Maybe String) blockStyleIndent x = @@ -178,6 +188,10 @@ Core.fieldName = (Core.Name "style"), Core.fieldTerm = (Typed.unTypedTerm style)}]})) +-- | DSL name token for hydra.ast.BracketExpr +bracketExprBracketExpr :: Typed.TypedName Ast.BracketExpr +bracketExprBracketExpr = Typed.TypedName (Core.Name "hydra.ast.BracketExpr") + -- | DSL accessor for the brackets field of hydra.ast.BracketExpr bracketExprBrackets :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.Brackets bracketExprBrackets x = @@ -290,6 +304,10 @@ Core.fieldName = (Core.Name "close"), Core.fieldTerm = (Typed.unTypedTerm close)}]})) +-- | DSL name token for hydra.ast.Brackets +bracketsBrackets :: Typed.TypedName Ast.Brackets +bracketsBrackets = Typed.TypedName (Core.Name "hydra.ast.Brackets") + -- | DSL accessor for the close field of hydra.ast.Brackets bracketsClose :: Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.Symbol bracketsClose x = @@ -360,6 +378,10 @@ Core.fieldName = (Core.Name "const"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.ast.Expr +exprExpr :: Typed.TypedName Ast.Expr +exprExpr = Typed.TypedName (Core.Name "hydra.ast.Expr") + -- | DSL injection for the indent variant of hydra.ast.Expr exprIndent :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.Expr exprIndent x = @@ -396,6 +418,10 @@ Core.fieldName = (Core.Name "allLines"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.ast.IndentStyle +indentStyleIndentStyle :: Typed.TypedName Ast.IndentStyle +indentStyleIndentStyle = Typed.TypedName (Core.Name "hydra.ast.IndentStyle") + -- | DSL injection for the subsequentLines variant of hydra.ast.IndentStyle indentStyleSubsequentLines :: Typed.TypedTerm String -> Typed.TypedTerm Ast.IndentStyle indentStyleSubsequentLines x = @@ -427,6 +453,10 @@ Core.projectionFieldName = (Core.Name "expr")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.IndentedExpression +indentedExpressionIndentedExpression :: Typed.TypedName Ast.IndentedExpression +indentedExpressionIndentedExpression = Typed.TypedName (Core.Name "hydra.ast.IndentedExpression") + -- | DSL accessor for the style field of hydra.ast.IndentedExpression indentedExpressionStyle :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.IndentStyle indentedExpressionStyle x = @@ -532,6 +562,10 @@ Core.projectionFieldName = (Core.Name "op")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.OpExpr +opExprOpExpr :: Typed.TypedName Ast.OpExpr +opExprOpExpr = Typed.TypedName (Core.Name "hydra.ast.OpExpr") + -- | DSL accessor for the rhs field of hydra.ast.OpExpr opExprRhs :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Expr opExprRhs x = @@ -613,6 +647,10 @@ Core.fieldName = (Core.Name "rhs"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.ast.Op +opOp :: Typed.TypedName Ast.Op +opOp = Typed.TypedName (Core.Name "hydra.ast.Op") + -- | DSL accessor for the padding field of hydra.ast.Op opPadding :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Padding opPadding x = @@ -786,6 +824,10 @@ Core.projectionFieldName = (Core.Name "left")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.Padding +paddingPadding :: Typed.TypedName Ast.Padding +paddingPadding = Typed.TypedName (Core.Name "hydra.ast.Padding") + -- | DSL accessor for the right field of hydra.ast.Padding paddingRight :: Typed.TypedTerm Ast.Padding -> Typed.TypedTerm Ast.Ws paddingRight x = @@ -836,6 +878,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.Precedence +precedencePrecedence :: Typed.TypedName Ast.Precedence +precedencePrecedence = Typed.TypedName (Core.Name "hydra.ast.Precedence") + -- | DSL constructor for hydra.ast.SeqExpr seqExpr :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.SeqExpr seqExpr op elements = @@ -867,6 +913,10 @@ Core.projectionFieldName = (Core.Name "op")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.SeqExpr +seqExprSeqExpr :: Typed.TypedName Ast.SeqExpr +seqExprSeqExpr = Typed.TypedName (Core.Name "hydra.ast.SeqExpr") + -- | DSL updater for the elements field of hydra.ast.SeqExpr seqExprWithElements :: Typed.TypedTerm Ast.SeqExpr -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.SeqExpr seqExprWithElements original newVal = @@ -908,6 +958,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.ast.Symbol +symbolSymbol :: Typed.TypedName Ast.Symbol +symbolSymbol = Typed.TypedName (Core.Name "hydra.ast.Symbol") + -- | DSL accessor for the body of hydra.ast.Precedence unPrecedence :: Typed.TypedTerm Ast.Precedence -> Typed.TypedTerm Int unPrecedence x = @@ -966,3 +1020,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "space"), Core.fieldTerm = Core.TermUnit}})) + +-- | DSL name token for hydra.ast.Ws +wsWs :: Typed.TypedName Ast.Ws +wsWs = Typed.TypedName (Core.Name "hydra.ast.Ws") diff --git a/src/main/haskell/Hydra/Dsl/Checking.hs b/src/main/haskell/Hydra/Dsl/Checking.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Checking.hs @@ -0,0 +1,544 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.checking + +module Hydra.Dsl.Checking where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Checking as Checking +import qualified Hydra.Coders as Coders +import qualified Hydra.Constants as Constants +import qualified Hydra.Core as Core +import qualified Hydra.Dependencies as Dependencies +import qualified Hydra.Docs as Docs +import qualified Hydra.Dsl.Ast as DslAst +import qualified Hydra.Dsl.Coders as DslCoders +import qualified Hydra.Dsl.Constants as DslConstants +import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Dsl.Dependencies as DslDependencies +import qualified Hydra.Dsl.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as DslErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Lexical as DslLexical +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Resolution as DslResolution +import qualified Hydra.Dsl.Rewriting as DslRewriting +import qualified Hydra.Dsl.Scoping as DslScoping +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Variables as DslVariables +import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Error.Checking as ErrorChecking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.File as File +import qualified Hydra.Formatting as Formatting +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Names as Names +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Reflect as Reflect +import qualified Hydra.Relational as Relational +import qualified Hydra.Resolution as Resolution +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Scoping as Scoping +import qualified Hydra.Show.Core as ShowCore +import qualified Hydra.Show.Errors as ShowErrors +import qualified Hydra.Show.Variants as ShowVariants +import qualified Hydra.Strip as Strip +import qualified Hydra.Substitution as Substitution +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variables as Variables +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL reference to hydra.checking.allEqual +allEqual :: Typed.TypedTerm [t0] -> Typed.TypedTerm Bool +allEqual arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.allEqual")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.checking.applyTypeArgumentsToType +applyTypeArgumentsToType :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error Core.Type) +applyTypeArgumentsToType 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.checking.applyTypeArgumentsToType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.checkForUnboundTypeVariables +checkForUnboundTypeVariables :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error ()) +checkForUnboundTypeVariables 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.checking.checkForUnboundTypeVariables")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.checking.checkNominalApplication +checkNominalApplication :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Either Errors.Error ((), Typing.InferenceContext)) +checkNominalApplication 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.checking.checkNominalApplication")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.checkSameType +checkSameType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm String -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Either Errors.Error Core.Type) +checkSameType 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.checking.checkSameType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.checkType +checkType :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error ()) +checkType 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.checking.checkType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.checkTypeSubst +checkTypeSubst :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Typing.TypeSubst -> Typed.TypedTerm (Either Errors.Error Typing.TypeSubst) +checkTypeSubst 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.checking.checkTypeSubst")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.checking.checkTypeVariables +checkTypeVariables :: Typed.TypedTerm t0 -> Typed.TypedTerm t1 -> Typed.TypedTerm () +checkTypeVariables arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.checkTypeVariables")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.checking.containsInScopeTypeVars +containsInScopeTypeVars :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +containsInScopeTypeVars arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.containsInScopeTypeVars")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.checking.normalizeTypeFreeVars +normalizeTypeFreeVars :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +normalizeTypeFreeVars arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.normalizeTypeFreeVars")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.checking.toFContext +toFContext :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Type) +toFContext arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.toFContext")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.checking.typeListsEffectivelyEqual +typeListsEffectivelyEqual :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Bool +typeListsEffectivelyEqual 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.checking.typeListsEffectivelyEqual")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.checking.typeOf +typeOf :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOf 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.checking.typeOf")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfAnnotatedTerm +typeOfAnnotatedTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfAnnotatedTerm 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.checking.typeOfAnnotatedTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfApplication +typeOfApplication :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Application -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfApplication 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.checking.typeOfApplication")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfCaseStatement +typeOfCaseStatement :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfCaseStatement 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.checking.typeOfCaseStatement")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfEither +typeOfEither :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Either Core.Term Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfEither 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.checking.typeOfEither")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfInjection +typeOfInjection :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Injection -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfInjection 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.checking.typeOfInjection")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfLambda +typeOfLambda :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Lambda -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfLambda 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.checking.typeOfLambda")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfLet +typeOfLet :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Let -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfLet 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.checking.typeOfLet")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfList +typeOfList :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm [Core.Term] -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfList 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.checking.typeOfList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfLiteral +typeOfLiteral :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Literal -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfLiteral 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.checking.typeOfLiteral")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfMap +typeOfMap :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (M.Map Core.Term Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfMap 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.checking.typeOfMap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfMaybe +typeOfMaybe :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfMaybe 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.checking.typeOfMaybe")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfPair +typeOfPair :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Core.Term, Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfPair 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.checking.typeOfPair")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfPrimitive +typeOfPrimitive :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfPrimitive 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.checking.typeOfPrimitive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfProjection +typeOfProjection :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Projection -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfProjection 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.checking.typeOfProjection")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfRecord +typeOfRecord :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Record -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfRecord 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.checking.typeOfRecord")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfSet +typeOfSet :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (S.Set Core.Term) -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfSet 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.checking.typeOfSet")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfTerm +typeOfTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error Core.Type) +typeOfTerm 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.checking.typeOfTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.checking.typeOfTypeApplication +typeOfTypeApplication :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfTypeApplication 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.checking.typeOfTypeApplication")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfTypeLambda +typeOfTypeLambda :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfTypeLambda 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.checking.typeOfTypeLambda")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfUnit +typeOfUnit :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfUnit 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.checking.typeOfUnit")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.checking.typeOfUnwrap +typeOfUnwrap :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfUnwrap 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.checking.typeOfUnwrap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfVariable +typeOfVariable :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfVariable 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.checking.typeOfVariable")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typeOfWrappedTerm +typeOfWrappedTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.WrappedTerm -> Typed.TypedTerm (Either Errors.Error (Core.Type, Typing.InferenceContext)) +typeOfWrappedTerm 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.checking.typeOfWrappedTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.checking.typesAllEffectivelyEqual +typesAllEffectivelyEqual :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Bool +typesAllEffectivelyEqual arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.checking.typesAllEffectivelyEqual")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.checking.typesEffectivelyEqual +typesEffectivelyEqual :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +typesEffectivelyEqual 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.checking.typesEffectivelyEqual")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) diff --git a/src/main/haskell/Hydra/Dsl/Coders.hs b/src/main/haskell/Hydra/Dsl/Coders.hs --- a/src/main/haskell/Hydra/Dsl/Coders.hs +++ b/src/main/haskell/Hydra/Dsl/Coders.hs @@ -6,12 +6,14 @@ import qualified Hydra.Coders as Coders import qualified Hydra.Core as Core +import qualified Hydra.Decode.Coders as DecodeCoders import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Errors as DslErrors import qualified Hydra.Dsl.File as DslFile import qualified Hydra.Dsl.Graph as DslGraph import qualified Hydra.Dsl.Util as DslUtil import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Encode.Coders as EncodeCoders import qualified Hydra.Errors as Errors import qualified Hydra.File as File import qualified Hydra.Graph as Graph @@ -42,6 +44,10 @@ Core.fieldName = (Core.Name "coder"), Core.fieldTerm = (Typed.unTypedTerm coder)}]})) +-- | DSL name token for hydra.coders.Adapter +adapterAdapter :: Typed.TypedName (Coders.Adapter t1 t2 v1 v2 e) +adapterAdapter = Typed.TypedName (Core.Name "hydra.coders.Adapter") + -- | DSL accessor for the coder field of hydra.coders.Adapter adapterCoder :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2 e) -> Typed.TypedTerm (Coders.Coder v1 v2 e) adapterCoder x = @@ -67,6 +73,10 @@ Core.fieldName = (Core.Name "adapters"), Core.fieldTerm = (Typed.unTypedTerm adapters)}]})) +-- | DSL name token for hydra.coders.AdapterContext +adapterContextAdapterContext :: Typed.TypedName Coders.AdapterContext +adapterContextAdapterContext = Typed.TypedName (Core.Name "hydra.coders.AdapterContext") + -- | DSL accessor for the adapters field of hydra.coders.AdapterContext adapterContextAdapters :: Typed.TypedTerm Coders.AdapterContext -> Typed.TypedTerm (M.Map Core.Name (Coders.Adapter Core.Type Core.Type Core.Term Core.Term Errors.Error)) adapterContextAdapters x = @@ -330,6 +340,10 @@ Core.fieldName = (Core.Name "decode"), Core.fieldTerm = (Typed.unTypedTerm decode)}]})) +-- | DSL name token for hydra.coders.Bicoder +bicoderBicoder :: Typed.TypedName (Coders.Bicoder t1 t2 v1 v2 e) +bicoderBicoder = Typed.TypedName (Core.Name "hydra.coders.Bicoder") + -- | DSL accessor for the decode field of hydra.coders.Bicoder bicoderDecode :: Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2 e) -> Typed.TypedTerm (t2 -> Coders.Adapter t2 t1 v2 v1 e) bicoderDecode x = @@ -419,6 +433,10 @@ Core.fieldName = (Core.Name "typeVariable"), Core.fieldTerm = (Typed.unTypedTerm typeVariable)}]})) +-- | DSL name token for hydra.coders.CaseConventions +caseConventionsCaseConventions :: Typed.TypedName Coders.CaseConventions +caseConventionsCaseConventions = Typed.TypedName (Core.Name "hydra.coders.CaseConventions") + -- | DSL accessor for the constant field of hydra.coders.CaseConventions caseConventionsConstant :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention caseConventionsConstant x = @@ -1252,6 +1270,10 @@ Core.fieldName = (Core.Name "decode"), Core.fieldTerm = (Typed.unTypedTerm decode)}]})) +-- | DSL name token for hydra.coders.Coder +coderCoder :: Typed.TypedName (Coders.Coder v1 v2 e) +coderCoder = Typed.TypedName (Core.Name "hydra.coders.Coder") + -- | DSL accessor for the decode field of hydra.coders.Coder coderDecode :: Typed.TypedTerm (Coders.Coder v1 v2 e) -> Typed.TypedTerm (v2 -> Either e v1) coderDecode x = @@ -1261,6 +1283,10 @@ Core.projectionFieldName = (Core.Name "decode")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.coders.CoderDirection +coderDirectionCoderDirection :: Typed.TypedName Coders.CoderDirection +coderDirectionCoderDirection = Typed.TypedName (Core.Name "hydra.coders.CoderDirection") + -- | DSL injection for the decode variant of hydra.coders.CoderDirection coderDirectionDecode :: Typed.TypedTerm Coders.CoderDirection coderDirectionDecode = @@ -1322,6 +1348,88 @@ Core.projectionFieldName = (Core.Name "decode")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL composition builder for the decoder of hydra.coders.Adapter +decodeAdapter :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError e) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Coders.Adapter t1 t2 v1 v2 e)) +decodeAdapter t1 t2 v1 v2 e = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.coders.adapter")), + Core.applicationArgument = (Typed.unTypedTerm t1)})), + Core.applicationArgument = (Typed.unTypedTerm t2)})), + Core.applicationArgument = (Typed.unTypedTerm v1)})), + Core.applicationArgument = (Typed.unTypedTerm v2)})), + Core.applicationArgument = (Typed.unTypedTerm e)})) + +-- | DSL composition builder for the decoder of hydra.coders.Bicoder +decodeBicoder :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError e) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Coders.Bicoder t1 t2 v1 v2 e)) +decodeBicoder t1 t2 v1 v2 e = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.coders.bicoder")), + Core.applicationArgument = (Typed.unTypedTerm t1)})), + Core.applicationArgument = (Typed.unTypedTerm t2)})), + Core.applicationArgument = (Typed.unTypedTerm v1)})), + Core.applicationArgument = (Typed.unTypedTerm v2)})), + Core.applicationArgument = (Typed.unTypedTerm e)})) + +-- | DSL composition builder for the decoder of hydra.coders.Coder +decodeCoder :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v1) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v2) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError e) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Coders.Coder v1 v2 e)) +decodeCoder v1 v2 e = + 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.decode.coders.coder")), + Core.applicationArgument = (Typed.unTypedTerm v1)})), + Core.applicationArgument = (Typed.unTypedTerm v2)})), + Core.applicationArgument = (Typed.unTypedTerm e)})) + +-- | DSL composition builder for the encoder of hydra.coders.Adapter +encodeAdapter :: Typed.TypedTerm (t1 -> Core.Term) -> Typed.TypedTerm (t2 -> Core.Term) -> Typed.TypedTerm (v1 -> Core.Term) -> Typed.TypedTerm (v2 -> Core.Term) -> Typed.TypedTerm (e -> Core.Term) -> Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2 e -> Core.Term) +encodeAdapter t1 t2 v1 v2 e = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.coders.adapter")), + Core.applicationArgument = (Typed.unTypedTerm t1)})), + Core.applicationArgument = (Typed.unTypedTerm t2)})), + Core.applicationArgument = (Typed.unTypedTerm v1)})), + Core.applicationArgument = (Typed.unTypedTerm v2)})), + Core.applicationArgument = (Typed.unTypedTerm e)})) + +-- | DSL composition builder for the encoder of hydra.coders.Bicoder +encodeBicoder :: Typed.TypedTerm (t1 -> Core.Term) -> Typed.TypedTerm (t2 -> Core.Term) -> Typed.TypedTerm (v1 -> Core.Term) -> Typed.TypedTerm (v2 -> Core.Term) -> Typed.TypedTerm (e -> Core.Term) -> Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2 e -> Core.Term) +encodeBicoder t1 t2 v1 v2 e = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.coders.bicoder")), + Core.applicationArgument = (Typed.unTypedTerm t1)})), + Core.applicationArgument = (Typed.unTypedTerm t2)})), + Core.applicationArgument = (Typed.unTypedTerm v1)})), + Core.applicationArgument = (Typed.unTypedTerm v2)})), + Core.applicationArgument = (Typed.unTypedTerm e)})) + +-- | DSL composition builder for the encoder of hydra.coders.Coder +encodeCoder :: Typed.TypedTerm (v1 -> Core.Term) -> Typed.TypedTerm (v2 -> Core.Term) -> Typed.TypedTerm (e -> Core.Term) -> Typed.TypedTerm (Coders.Coder v1 v2 e -> Core.Term) +encodeCoder v1 v2 e = + 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.encode.coders.coder")), + Core.applicationArgument = (Typed.unTypedTerm v1)})), + Core.applicationArgument = (Typed.unTypedTerm v2)})), + Core.applicationArgument = (Typed.unTypedTerm e)})) + -- | DSL constructor for hydra.coders.Language language :: Typed.TypedTerm Coders.LanguageName -> Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Coders.LanguageFeature) -> Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm File.FileExtension -> Typed.TypedTerm Coders.Language language name constraints supportedFeatures caseConventions defaultFileExtension = @@ -1405,6 +1513,10 @@ Core.projectionFieldName = (Core.Name "integerTypes")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.coders.LanguageConstraints +languageConstraintsLanguageConstraints :: Typed.TypedName Coders.LanguageConstraints +languageConstraintsLanguageConstraints = Typed.TypedName (Core.Name "hydra.coders.LanguageConstraints") + -- | DSL accessor for the literalVariants field of hydra.coders.LanguageConstraints languageConstraintsLiteralVariants :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Variants.LiteralVariant) languageConstraintsLiteralVariants x = @@ -1720,6 +1832,10 @@ Core.projectionFieldName = (Core.Name "defaultFileExtension")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.coders.LanguageFeature +languageFeatureLanguageFeature :: Typed.TypedName Coders.LanguageFeature +languageFeatureLanguageFeature = Typed.TypedName (Core.Name "hydra.coders.LanguageFeature") + -- | DSL injection for the nestedCaseStatements variant of hydra.coders.LanguageFeature languageFeatureNestedCaseStatements :: Typed.TypedTerm Coders.LanguageFeature languageFeatureNestedCaseStatements = @@ -1747,6 +1863,10 @@ Core.fieldName = (Core.Name "partialApplication"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.coders.Language +languageLanguage :: Typed.TypedName Coders.Language +languageLanguage = Typed.TypedName (Core.Name "hydra.coders.Language") + -- | DSL accessor for the name field of hydra.coders.Language languageName :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.LanguageName languageName x = @@ -1763,6 +1883,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.coders.LanguageName +languageNameLanguageName :: Typed.TypedName Coders.LanguageName +languageNameLanguageName = Typed.TypedName (Core.Name "hydra.coders.LanguageName") + -- | DSL accessor for the supportedFeatures field of hydra.coders.Language languageSupportedFeatures :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm (S.Set Coders.LanguageFeature) languageSupportedFeatures x = @@ -1979,6 +2103,10 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "pre"), Core.fieldTerm = Core.TermUnit}})) + +-- | DSL name token for hydra.coders.TraversalOrder +traversalOrderTraversalOrder :: Typed.TypedName Coders.TraversalOrder +traversalOrderTraversalOrder = Typed.TypedName (Core.Name "hydra.coders.TraversalOrder") -- | DSL accessor for the body of hydra.coders.LanguageName unLanguageName :: Typed.TypedTerm Coders.LanguageName -> Typed.TypedTerm String diff --git a/src/main/haskell/Hydra/Dsl/Constants.hs b/src/main/haskell/Hydra/Dsl/Constants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Constants.hs @@ -0,0 +1,144 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.constants + +module Hydra.Dsl.Constants where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Constants as Constants +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.constants.debugInference +debugInference :: Typed.TypedTerm Bool +debugInference = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.debugInference")) + +-- | DSL reference to hydra.constants.ignoredVariable +ignoredVariable :: Typed.TypedTerm String +ignoredVariable = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.ignoredVariable")) + +-- | DSL reference to hydra.constants.keyClasses +keyClasses :: Typed.TypedTerm Core.Name +keyClasses = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyClasses")) + +-- | DSL reference to hydra.constants.keyDebugId +keyDebugId :: Typed.TypedTerm Core.Name +keyDebugId = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyDebugId")) + +-- | DSL reference to hydra.constants.keyDeprecated +keyDeprecated :: Typed.TypedTerm Core.Name +keyDeprecated = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyDeprecated")) + +-- | DSL reference to hydra.constants.keyDescription +keyDescription :: Typed.TypedTerm Core.Name +keyDescription = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyDescription")) + +-- | DSL reference to hydra.constants.keyExclude +keyExclude :: Typed.TypedTerm Core.Name +keyExclude = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyExclude")) + +-- | DSL reference to hydra.constants.keyFirstClassType +keyFirstClassType :: Typed.TypedTerm Core.Name +keyFirstClassType = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyFirstClassType")) + +-- | DSL reference to hydra.constants.keyFreshTypeVariableCount +keyFreshTypeVariableCount :: Typed.TypedTerm Core.Name +keyFreshTypeVariableCount = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyFreshTypeVariableCount")) + +-- | DSL reference to hydra.constants.keyMaxLength +keyMaxLength :: Typed.TypedTerm Core.Name +keyMaxLength = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyMaxLength")) + +-- | DSL reference to hydra.constants.keyMinLength +keyMinLength :: Typed.TypedTerm Core.Name +keyMinLength = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyMinLength")) + +-- | DSL reference to hydra.constants.keyPreserveFieldName +keyPreserveFieldName :: Typed.TypedTerm Core.Name +keyPreserveFieldName = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyPreserveFieldName")) + +-- | DSL reference to hydra.constants.keyType +keyType :: Typed.TypedTerm Core.Name +keyType = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.keyType")) + +-- | DSL reference to hydra.constants.maxInt32 +maxInt32 :: Typed.TypedTerm Int +maxInt32 = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.maxInt32")) + +-- | DSL reference to hydra.constants.maxTraceDepth +maxTraceDepth :: Typed.TypedTerm Int +maxTraceDepth = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.maxTraceDepth")) + +-- | DSL reference to hydra.constants.regexCamelCase +regexCamelCase :: Typed.TypedTerm String +regexCamelCase = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.regexCamelCase")) + +-- | DSL reference to hydra.constants.regexNamespace +regexNamespace :: Typed.TypedTerm String +regexNamespace = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.regexNamespace")) + +-- | DSL reference to hydra.constants.regexPackageName +regexPackageName :: Typed.TypedTerm String +regexPackageName = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.regexPackageName")) + +-- | DSL reference to hydra.constants.regexPascalCase +regexPascalCase :: Typed.TypedTerm String +regexPascalCase = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.regexPascalCase")) + +-- | DSL reference to hydra.constants.warningAutoGeneratedFile +warningAutoGeneratedFile :: Typed.TypedTerm String +warningAutoGeneratedFile = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.warningAutoGeneratedFile")) diff --git a/src/main/haskell/Hydra/Dsl/Core.hs b/src/main/haskell/Hydra/Dsl/Core.hs --- a/src/main/haskell/Hydra/Dsl/Core.hs +++ b/src/main/haskell/Hydra/Dsl/Core.hs @@ -5,6 +5,8 @@ module Hydra.Dsl.Core where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci @@ -26,6 +28,10 @@ Core.fieldName = (Core.Name "annotation"), Core.fieldTerm = (Typed.unTypedTerm annotation)}]})) +-- | DSL name token for hydra.core.AnnotatedTerm +annotatedTermAnnotatedTerm :: Typed.TypedName Core.AnnotatedTerm +annotatedTermAnnotatedTerm = Typed.TypedName (Core.Name "hydra.core.AnnotatedTerm") + -- | DSL accessor for the annotation field of hydra.core.AnnotatedTerm annotatedTermAnnotation :: Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm Core.Term annotatedTermAnnotation x = @@ -91,6 +97,10 @@ Core.fieldName = (Core.Name "annotation"), Core.fieldTerm = (Typed.unTypedTerm annotation)}]})) +-- | DSL name token for hydra.core.AnnotatedType +annotatedTypeAnnotatedType :: Typed.TypedName Core.AnnotatedType +annotatedTypeAnnotatedType = Typed.TypedName (Core.Name "hydra.core.AnnotatedType") + -- | DSL accessor for the annotation field of hydra.core.AnnotatedType annotatedTypeAnnotation :: Typed.TypedTerm Core.AnnotatedType -> Typed.TypedTerm Core.Term annotatedTypeAnnotation x = @@ -156,6 +166,10 @@ Core.fieldName = (Core.Name "argument"), Core.fieldTerm = (Typed.unTypedTerm argument)}]})) +-- | DSL name token for hydra.core.Application +applicationApplication :: Typed.TypedName Core.Application +applicationApplication = Typed.TypedName (Core.Name "hydra.core.Application") + -- | DSL accessor for the argument field of hydra.core.Application applicationArgument :: Typed.TypedTerm Core.Application -> Typed.TypedTerm Core.Term applicationArgument x = @@ -187,6 +201,10 @@ Core.fieldName = (Core.Name "argument"), Core.fieldTerm = (Typed.unTypedTerm argument)}]})) +-- | DSL name token for hydra.core.ApplicationType +applicationTypeApplicationType :: Typed.TypedName Core.ApplicationType +applicationTypeApplicationType = Typed.TypedName (Core.Name "hydra.core.ApplicationType") + -- | DSL accessor for the argument field of hydra.core.ApplicationType applicationTypeArgument :: Typed.TypedTerm Core.ApplicationType -> Typed.TypedTerm Core.Type applicationTypeArgument x = @@ -289,6 +307,10 @@ Core.fieldName = (Core.Name "typeScheme"), Core.fieldTerm = (Typed.unTypedTerm typeScheme)}]})) +-- | DSL name token for hydra.core.Binding +bindingBinding :: Typed.TypedName Core.Binding +bindingBinding = Typed.TypedName (Core.Name "hydra.core.Binding") + -- | DSL accessor for the name field of hydra.core.Binding bindingName :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Core.Name bindingName x = @@ -401,6 +423,10 @@ Core.fieldName = (Core.Name "handler"), Core.fieldTerm = (Typed.unTypedTerm handler)}]})) +-- | DSL name token for hydra.core.CaseAlternative +caseAlternativeCaseAlternative :: Typed.TypedName Core.CaseAlternative +caseAlternativeCaseAlternative = Typed.TypedName (Core.Name "hydra.core.CaseAlternative") + -- | DSL accessor for the handler field of hydra.core.CaseAlternative caseAlternativeHandler :: Typed.TypedTerm Core.CaseAlternative -> Typed.TypedTerm Core.Term caseAlternativeHandler x = @@ -469,6 +495,10 @@ Core.fieldName = (Core.Name "cases"), Core.fieldTerm = (Typed.unTypedTerm cases)}]})) +-- | DSL name token for hydra.core.CaseStatement +caseStatementCaseStatement :: Typed.TypedName Core.CaseStatement +caseStatementCaseStatement = Typed.TypedName (Core.Name "hydra.core.CaseStatement") + -- | DSL accessor for the cases field of hydra.core.CaseStatement caseStatementCases :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm [Core.CaseAlternative] caseStatementCases x = @@ -581,6 +611,10 @@ Core.fieldName = (Core.Name "right"), Core.fieldTerm = (Typed.unTypedTerm right)}]})) +-- | DSL name token for hydra.core.EitherType +eitherTypeEitherType :: Typed.TypedName Core.EitherType +eitherTypeEitherType = Typed.TypedName (Core.Name "hydra.core.EitherType") + -- | DSL accessor for the left field of hydra.core.EitherType eitherTypeLeft :: Typed.TypedTerm Core.EitherType -> Typed.TypedTerm Core.Type eitherTypeLeft x = @@ -646,6 +680,10 @@ Core.fieldName = (Core.Name "term"), Core.fieldTerm = (Typed.unTypedTerm term)}]})) +-- | DSL name token for hydra.core.Field +fieldField :: Typed.TypedName Core.Field +fieldField = Typed.TypedName (Core.Name "hydra.core.Field") + -- | DSL accessor for the name field of hydra.core.Field fieldName :: Typed.TypedTerm Core.Field -> Typed.TypedTerm Core.Name fieldName x = @@ -677,6 +715,10 @@ Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm type_)}]})) +-- | DSL name token for hydra.core.FieldType +fieldTypeFieldType :: Typed.TypedName Core.FieldType +fieldTypeFieldType = Typed.TypedName (Core.Name "hydra.core.FieldType") + -- | DSL accessor for the name field of hydra.core.FieldType fieldTypeName :: Typed.TypedTerm Core.FieldType -> Typed.TypedTerm Core.Name fieldTypeName x = @@ -781,6 +823,10 @@ Core.fieldName = (Core.Name "float64"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.core.FloatType +floatTypeFloatType :: Typed.TypedName Core.FloatType +floatTypeFloatType = Typed.TypedName (Core.Name "hydra.core.FloatType") + -- | DSL injection for the float32 variant of hydra.core.FloatValue floatValueFloat32 :: Typed.TypedTerm Float -> Typed.TypedTerm Core.FloatValue floatValueFloat32 x = @@ -799,6 +845,10 @@ Core.fieldName = (Core.Name "float64"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.FloatValue +floatValueFloatValue :: Typed.TypedName Core.FloatValue +floatValueFloatValue = Typed.TypedName (Core.Name "hydra.core.FloatValue") + -- | DSL constructor for hydra.core.ForallType forallType :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.ForallType forallType parameter body = @@ -821,6 +871,10 @@ Core.projectionFieldName = (Core.Name "body")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.ForallType +forallTypeForallType :: Typed.TypedName Core.ForallType +forallTypeForallType = Typed.TypedName (Core.Name "hydra.core.ForallType") + -- | DSL accessor for the parameter field of hydra.core.ForallType forallTypeParameter :: Typed.TypedTerm Core.ForallType -> Typed.TypedTerm Core.Name forallTypeParameter x = @@ -895,6 +949,10 @@ Core.projectionFieldName = (Core.Name "domain")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.FunctionType +functionTypeFunctionType :: Typed.TypedName Core.FunctionType +functionTypeFunctionType = Typed.TypedName (Core.Name "hydra.core.FunctionType") + -- | DSL updater for the codomain field of hydra.core.FunctionType functionTypeWithCodomain :: Typed.TypedTerm Core.FunctionType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.FunctionType functionTypeWithCodomain original newVal = @@ -951,6 +1009,10 @@ Core.projectionFieldName = (Core.Name "field")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Injection +injectionInjection :: Typed.TypedName Core.Injection +injectionInjection = Typed.TypedName (Core.Name "hydra.core.Injection") + -- | DSL accessor for the typeName field of hydra.core.Injection injectionTypeName :: Typed.TypedTerm Core.Injection -> Typed.TypedTerm Core.Name injectionTypeName x = @@ -1039,6 +1101,10 @@ Core.fieldName = (Core.Name "int8"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.core.IntegerType +integerTypeIntegerType :: Typed.TypedName Core.IntegerType +integerTypeIntegerType = Typed.TypedName (Core.Name "hydra.core.IntegerType") + -- | DSL injection for the uint16 variant of hydra.core.IntegerType integerTypeUint16 :: Typed.TypedTerm Core.IntegerType integerTypeUint16 = @@ -1120,6 +1186,10 @@ Core.fieldName = (Core.Name "int8"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.IntegerValue +integerValueIntegerValue :: Typed.TypedName Core.IntegerValue +integerValueIntegerValue = Typed.TypedName (Core.Name "hydra.core.IntegerValue") + -- | DSL injection for the uint16 variant of hydra.core.IntegerValue integerValueUint16 :: Typed.TypedTerm Int -> Typed.TypedTerm Core.IntegerValue integerValueUint16 x = @@ -1190,6 +1260,10 @@ Core.projectionFieldName = (Core.Name "domain")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Lambda +lambdaLambda :: Typed.TypedName Core.Lambda +lambdaLambda = Typed.TypedName (Core.Name "hydra.core.Lambda") + -- | DSL accessor for the parameter field of hydra.core.Lambda lambdaParameter :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm Core.Name lambdaParameter x = @@ -1302,6 +1376,10 @@ Core.projectionFieldName = (Core.Name "body")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Let +letLet :: Typed.TypedName Core.Let +letLet = Typed.TypedName (Core.Name "hydra.core.Let") + -- | DSL updater for the bindings field of hydra.core.Let letWithBindings :: Typed.TypedTerm Core.Let -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Let letWithBindings original newVal = @@ -1381,6 +1459,10 @@ Core.fieldName = (Core.Name "integer"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.Literal +literalLiteral :: Typed.TypedName Core.Literal +literalLiteral = Typed.TypedName (Core.Name "hydra.core.Literal") + -- | DSL injection for the string variant of hydra.core.Literal literalString :: Typed.TypedTerm String -> Typed.TypedTerm Core.Literal literalString x = @@ -1435,6 +1517,10 @@ Core.fieldName = (Core.Name "integer"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.LiteralType +literalTypeLiteralType :: Typed.TypedName Core.LiteralType +literalTypeLiteralType = Typed.TypedName (Core.Name "hydra.core.LiteralType") + -- | DSL injection for the string variant of hydra.core.LiteralType literalTypeString :: Typed.TypedTerm Core.LiteralType literalTypeString = @@ -1466,6 +1552,10 @@ Core.projectionFieldName = (Core.Name "keys")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.MapType +mapTypeMapType :: Typed.TypedName Core.MapType +mapTypeMapType = Typed.TypedName (Core.Name "hydra.core.MapType") + -- | DSL accessor for the values field of hydra.core.MapType mapTypeValues :: Typed.TypedTerm Core.MapType -> Typed.TypedTerm Core.Type mapTypeValues x = @@ -1516,6 +1606,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Name +nameName :: Typed.TypedName Core.Name +nameName = Typed.TypedName (Core.Name "hydra.core.Name") + -- | DSL constructor for hydra.core.PairType pairType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.PairType pairType first second = @@ -1538,6 +1632,10 @@ Core.projectionFieldName = (Core.Name "first")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.PairType +pairTypePairType :: Typed.TypedName Core.PairType +pairTypePairType = Typed.TypedName (Core.Name "hydra.core.PairType") + -- | DSL accessor for the second field of hydra.core.PairType pairTypeSecond :: Typed.TypedTerm Core.PairType -> Typed.TypedTerm Core.Type pairTypeSecond x = @@ -1603,6 +1701,10 @@ Core.projectionFieldName = (Core.Name "fieldName")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Projection +projectionProjection :: Typed.TypedName Core.Projection +projectionProjection = Typed.TypedName (Core.Name "hydra.core.Projection") + -- | DSL accessor for the typeName field of hydra.core.Projection projectionTypeName :: Typed.TypedTerm Core.Projection -> Typed.TypedTerm Core.Name projectionTypeName x = @@ -1668,6 +1770,10 @@ Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.Record +recordRecord :: Typed.TypedName Core.Record +recordRecord = Typed.TypedName (Core.Name "hydra.core.Record") + -- | DSL accessor for the typeName field of hydra.core.Record recordTypeName :: Typed.TypedTerm Core.Record -> Typed.TypedTerm Core.Name recordTypeName x = @@ -1846,6 +1952,10 @@ Core.fieldName = (Core.Name "set"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.Term +termTerm :: Typed.TypedName Core.Term +termTerm = Typed.TypedName (Core.Name "hydra.core.Term") + -- | DSL injection for the typeApplication variant of hydra.core.Term termTypeApplication :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Term termTypeApplication x = @@ -1949,6 +2059,10 @@ Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.TypeApplicationTerm +typeApplicationTermTypeApplicationTerm :: Typed.TypedName Core.TypeApplicationTerm +typeApplicationTermTypeApplicationTerm = Typed.TypedName (Core.Name "hydra.core.TypeApplicationTerm") + -- | DSL updater for the body field of hydra.core.TypeApplicationTerm typeApplicationTermWithBody :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.TypeApplicationTerm typeApplicationTermWithBody original newVal = @@ -1992,6 +2106,10 @@ Core.fieldName = (Core.Name "simple"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.TypeClassConstraint +typeClassConstraintTypeClassConstraint :: Typed.TypedName Core.TypeClassConstraint +typeClassConstraintTypeClassConstraint = Typed.TypedName (Core.Name "hydra.core.TypeClassConstraint") + -- | DSL injection for the effect variant of hydra.core.Type typeEffect :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type typeEffect x = @@ -2059,6 +2177,10 @@ Core.projectionFieldName = (Core.Name "parameter")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.TypeLambda +typeLambdaTypeLambda :: Typed.TypedName Core.TypeLambda +typeLambdaTypeLambda = Typed.TypedName (Core.Name "hydra.core.TypeLambda") + -- | DSL updater for the body field of hydra.core.TypeLambda typeLambdaWithBody :: Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.TypeLambda typeLambdaWithBody original newVal = @@ -2181,6 +2303,10 @@ Core.projectionFieldName = (Core.Name "constraints")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.TypeScheme +typeSchemeTypeScheme :: Typed.TypedName Core.TypeScheme +typeSchemeTypeScheme = Typed.TypedName (Core.Name "hydra.core.TypeScheme") + -- | DSL accessor for the variables field of hydra.core.TypeScheme typeSchemeVariables :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm [Core.Name] typeSchemeVariables x = @@ -2271,6 +2397,10 @@ Core.fieldName = (Core.Name "set"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.core.Type +typeType :: Typed.TypedName Core.Type +typeType = Typed.TypedName (Core.Name "hydra.core.Type") + -- | DSL injection for the union variant of hydra.core.Type typeUnion :: Typed.TypedTerm [Core.FieldType] -> Typed.TypedTerm Core.Type typeUnion x = @@ -2317,6 +2447,10 @@ Core.projectionFieldName = (Core.Name "classes")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.core.TypeVariableConstraints +typeVariableConstraintsTypeVariableConstraints :: Typed.TypedName Core.TypeVariableConstraints +typeVariableConstraintsTypeVariableConstraints = Typed.TypedName (Core.Name "hydra.core.TypeVariableConstraints") + -- | DSL updater for the classes field of hydra.core.TypeVariableConstraints typeVariableConstraintsWithClasses :: Typed.TypedTerm Core.TypeVariableConstraints -> Typed.TypedTerm [Core.TypeClassConstraint] -> Typed.TypedTerm Core.TypeVariableConstraints typeVariableConstraintsWithClasses original newVal = @@ -2416,3 +2550,7 @@ Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), Core.projectionFieldName = (Core.Name "body")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL name token for hydra.core.WrappedTerm +wrappedTermWrappedTerm :: Typed.TypedName Core.WrappedTerm +wrappedTermWrappedTerm = Typed.TypedName (Core.Name "hydra.core.WrappedTerm") diff --git a/src/main/haskell/Hydra/Dsl/Dependencies.hs b/src/main/haskell/Hydra/Dsl/Dependencies.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Dependencies.hs @@ -0,0 +1,203 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.dependencies + +module Hydra.Dsl.Dependencies where + +import qualified Hydra.Annotations as Annotations +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Constants as Constants +import qualified Hydra.Core as Core +import qualified Hydra.Dependencies as Dependencies +import qualified Hydra.Docs as Docs +import qualified Hydra.Dsl.Annotations as DslAnnotations +import qualified Hydra.Dsl.Ast as DslAst +import qualified Hydra.Dsl.Coders as DslCoders +import qualified Hydra.Dsl.Constants as DslConstants +import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Dsl.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Lexical as DslLexical +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Rewriting as DslRewriting +import qualified Hydra.Dsl.Sorting as DslSorting +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Variables as DslVariables +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Names as Names +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Sorting as Sorting +import qualified Hydra.Strip as Strip +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variables as Variables +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL reference to hydra.dependencies.definitionsWithDependencies +definitionsWithDependencies :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Either Errors.Error [Core.Binding]) +definitionsWithDependencies 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.dependencies.definitionsWithDependencies")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.dependencies.flattenLetTerms +flattenLetTerms :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +flattenLetTerms arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.flattenLetTerms")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.inlineType +inlineType :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error Core.Type) +inlineType arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.inlineType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.dependencies.isLambda +isLambda :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isLambda arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.isLambda")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.liftLambdaAboveLet +liftLambdaAboveLet :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +liftLambdaAboveLet arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.liftLambdaAboveLet")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.pruneLet +pruneLet :: Typed.TypedTerm Core.Let -> Typed.TypedTerm Core.Let +pruneLet arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.pruneLet")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.replaceTypedefs +replaceTypedefs :: Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +replaceTypedefs arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.replaceTypedefs")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.dependencies.simplifyTerm +simplifyTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +simplifyTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.simplifyTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.termDependencyNames +termDependencyNames :: Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (S.Set Core.Name) +termDependencyNames 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.dependencies.termDependencyNames")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.dependencies.toShortNames +toShortNames :: Typed.TypedTerm [Core.Name] -> Typed.TypedTerm (M.Map Core.Name Core.Name) +toShortNames arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.toShortNames")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.topologicalSortBindingMap +topologicalSortBindingMap :: Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm [[(Core.Name, Core.Term)]] +topologicalSortBindingMap arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.topologicalSortBindingMap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.topologicalSortBindings +topologicalSortBindings :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Either [[Core.Name]] [Core.Name]) +topologicalSortBindings arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.topologicalSortBindings")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.topologicalSortTypeDefinitions +topologicalSortTypeDefinitions :: Typed.TypedTerm [Packaging.TypeDefinition] -> Typed.TypedTerm [[Packaging.TypeDefinition]] +topologicalSortTypeDefinitions arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.topologicalSortTypeDefinitions")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.dependencies.typeDependencyNames +typeDependencyNames :: Typed.TypedTerm Bool -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (S.Set Core.Name) +typeDependencyNames arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.typeDependencyNames")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.dependencies.typeNamesInType +typeNamesInType :: Ord t0 => (Typed.TypedTerm Core.Type -> Typed.TypedTerm (S.Set t0)) +typeNamesInType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.dependencies.typeNamesInType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Docs.hs b/src/main/haskell/Hydra/Dsl/Docs.hs --- a/src/main/haskell/Hydra/Dsl/Docs.hs +++ b/src/main/haskell/Hydra/Dsl/Docs.hs @@ -5,12 +5,18 @@ module Hydra.Dsl.Docs where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Docs as DecodeDocs import qualified Hydra.Docs as Docs import qualified Hydra.Dsl.Packaging as DslPackaging +import qualified Hydra.Encode.Docs as EncodeDocs import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci + +-- | DSL name token for hydra.docs.DocSegment +docSegmentDocSegment :: Typed.TypedName Docs.DocSegment +docSegmentDocSegment = Typed.TypedName (Core.Name "hydra.docs.DocSegment") -- | DSL injection for the ref variant of hydra.docs.DocSegment docSegmentRef :: Typed.TypedTerm Packaging.EntityReference -> Typed.TypedTerm Docs.DocSegment diff --git a/src/main/haskell/Hydra/Dsl/Environment.hs b/src/main/haskell/Hydra/Dsl/Environment.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Environment.hs @@ -0,0 +1,193 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.environment + +module Hydra.Dsl.Environment where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Lexical as DslLexical +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Scoping as DslScoping +import qualified Hydra.Dsl.Sorting as DslSorting +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Variables as DslVariables +import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Encode.Core as EncodeCore +import qualified Hydra.Environment as Environment +import qualified Hydra.Error.Checking as Checking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Scoping as Scoping +import qualified Hydra.Sorting as Sorting +import qualified Hydra.Strip as Strip +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variables as Variables +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | DSL reference to hydra.environment.definitionAsTypeApplicationTerm +definitionAsTypeApplicationTerm :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm (Either Errors.Error Core.TypeApplicationTerm) +definitionAsTypeApplicationTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.definitionAsTypeApplicationTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.environment.graphAsLet +graphAsLet :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Let +graphAsLet arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.graphAsLet")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.environment.graphAsTerm +graphAsTerm :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +graphAsTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.graphAsTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.environment.graphAsTypes +graphAsTypes :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Either Errors.DecodingError (M.Map Core.Name Core.Type)) +graphAsTypes arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.graphAsTypes")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.environment.partitionDefinitions +partitionDefinitions :: Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm ([Packaging.TypeDefinition], [Packaging.TermDefinition]) +partitionDefinitions arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.partitionDefinitions")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.environment.reorderDefs +reorderDefs :: Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm [Packaging.Definition] +reorderDefs arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.reorderDefs")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.environment.schemaGraphToTypingEnvironment +schemaGraphToTypingEnvironment :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (Either Errors.Error (M.Map Core.Name Core.TypeScheme)) +schemaGraphToTypingEnvironment arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.schemaGraphToTypingEnvironment")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.environment.termAsBindings +termAsBindings :: Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Binding] +termAsBindings arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.termAsBindings")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.environment.typesToDefinitions +typesToDefinitions :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm [Core.Binding] +typesToDefinitions arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.typesToDefinitions")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.environment.withLambdaContext +withLambdaContext :: Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t1) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Lambda -> Typed.TypedTerm (t1 -> t2) -> Typed.TypedTerm t2 +withLambdaContext arg0 arg1 arg2 arg3 arg4 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.withLambdaContext")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})) + +-- | DSL reference to hydra.environment.withLetContext +withLetContext :: Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t1) -> Typed.TypedTerm (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Let -> Typed.TypedTerm (t1 -> t2) -> Typed.TypedTerm t2 +withLetContext arg0 arg1 arg2 arg3 arg4 arg5 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.withLetContext")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})), + Core.applicationArgument = (Typed.unTypedTerm arg5)})) + +-- | DSL reference to hydra.environment.withTypeLambdaContext +withTypeLambdaContext :: Typed.TypedTerm (t0 -> Graph.Graph) -> Typed.TypedTerm (Graph.Graph -> t0 -> t1) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm (t1 -> t2) -> Typed.TypedTerm t2 +withTypeLambdaContext arg0 arg1 arg2 arg3 arg4 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.environment.withTypeLambdaContext")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})) diff --git a/src/main/haskell/Hydra/Dsl/Error/Checking.hs b/src/main/haskell/Hydra/Dsl/Error/Checking.hs --- a/src/main/haskell/Hydra/Dsl/Error/Checking.hs +++ b/src/main/haskell/Hydra/Dsl/Error/Checking.hs @@ -5,10 +5,12 @@ module Hydra.Dsl.Error.Checking where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Error.Checking as DecodeErrorChecking import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Typing as DslTyping import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Encode.Error.Checking as EncodeErrorChecking import qualified Hydra.Error.Checking as Checking import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed @@ -18,6 +20,10 @@ import qualified Data.Scientific as Sci import qualified Data.Set as S +-- | DSL name token for hydra.error.checking.CheckingError +checkingErrorCheckingError :: Typed.TypedName Checking.CheckingError +checkingErrorCheckingError = Typed.TypedName (Core.Name "hydra.error.checking.CheckingError") + -- | DSL injection for the incorrectUnification variant of hydra.error.checking.CheckingError checkingErrorIncorrectUnification :: Typed.TypedTerm Checking.IncorrectUnificationError -> Typed.TypedTerm Checking.CheckingError checkingErrorIncorrectUnification x = @@ -145,6 +151,11 @@ Core.fieldName = (Core.Name "substitution"), Core.fieldTerm = (Typed.unTypedTerm substitution)}]})) +-- | DSL name token for hydra.error.checking.IncorrectUnificationError +incorrectUnificationErrorIncorrectUnificationError :: Typed.TypedName Checking.IncorrectUnificationError +incorrectUnificationErrorIncorrectUnificationError = + Typed.TypedName (Core.Name "hydra.error.checking.IncorrectUnificationError") + -- | DSL accessor for the substitution field of hydra.error.checking.IncorrectUnificationError incorrectUnificationErrorSubstitution :: Typed.TypedTerm Checking.IncorrectUnificationError -> Typed.TypedTerm Typing.TypeSubst incorrectUnificationErrorSubstitution x = @@ -177,6 +188,10 @@ Core.fieldName = (Core.Name "typeArguments"), Core.fieldTerm = (Typed.unTypedTerm typeArguments)}]})) +-- | DSL name token for hydra.error.checking.NotAForallTypeError +notAForallTypeErrorNotAForallTypeError :: Typed.TypedName Checking.NotAForallTypeError +notAForallTypeErrorNotAForallTypeError = Typed.TypedName (Core.Name "hydra.error.checking.NotAForallTypeError") + -- | DSL accessor for the type field of hydra.error.checking.NotAForallTypeError notAForallTypeErrorType :: Typed.TypedTerm Checking.NotAForallTypeError -> Typed.TypedTerm Core.Type notAForallTypeErrorType x = @@ -239,6 +254,10 @@ Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm type_)}]})) +-- | DSL name token for hydra.error.checking.NotAFunctionTypeError +notAFunctionTypeErrorNotAFunctionTypeError :: Typed.TypedName Checking.NotAFunctionTypeError +notAFunctionTypeErrorNotAFunctionTypeError = Typed.TypedName (Core.Name "hydra.error.checking.NotAFunctionTypeError") + -- | DSL accessor for the type field of hydra.error.checking.NotAFunctionTypeError notAFunctionTypeErrorType :: Typed.TypedTerm Checking.NotAFunctionTypeError -> Typed.TypedTerm Core.Type notAFunctionTypeErrorType x = @@ -280,6 +299,10 @@ Core.projectionFieldName = (Core.Name "message")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.OtherCheckingError +otherCheckingErrorOtherCheckingError :: Typed.TypedName Checking.OtherCheckingError +otherCheckingErrorOtherCheckingError = Typed.TypedName (Core.Name "hydra.error.checking.OtherCheckingError") + -- | DSL accessor for the path field of hydra.error.checking.OtherCheckingError otherCheckingErrorPath :: Typed.TypedTerm Checking.OtherCheckingError -> Typed.TypedTerm Paths.SubtermPath otherCheckingErrorPath x = @@ -378,6 +401,10 @@ Core.projectionFieldName = (Core.Name "typeArguments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.TypeArityMismatchError +typeArityMismatchErrorTypeArityMismatchError :: Typed.TypedName Checking.TypeArityMismatchError +typeArityMismatchErrorTypeArityMismatchError = Typed.TypedName (Core.Name "hydra.error.checking.TypeArityMismatchError") + -- | DSL updater for the actualArity field of hydra.error.checking.TypeArityMismatchError typeArityMismatchErrorWithActualArity :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Int -> Typed.TypedTerm Checking.TypeArityMismatchError typeArityMismatchErrorWithActualArity original newVal = @@ -533,6 +560,10 @@ Core.projectionFieldName = (Core.Name "expectedType")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.TypeMismatchError +typeMismatchErrorTypeMismatchError :: Typed.TypedName Checking.TypeMismatchError +typeMismatchErrorTypeMismatchError = Typed.TypedName (Core.Name "hydra.error.checking.TypeMismatchError") + -- | DSL updater for the actualType field of hydra.error.checking.TypeMismatchError typeMismatchErrorWithActualType :: Typed.TypedTerm Checking.TypeMismatchError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.TypeMismatchError typeMismatchErrorWithActualType original newVal = @@ -589,6 +620,11 @@ Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UnboundTypeVariablesError +unboundTypeVariablesErrorUnboundTypeVariablesError :: Typed.TypedName Checking.UnboundTypeVariablesError +unboundTypeVariablesErrorUnboundTypeVariablesError = + Typed.TypedName (Core.Name "hydra.error.checking.UnboundTypeVariablesError") + -- | DSL accessor for the variables field of hydra.error.checking.UnboundTypeVariablesError unboundTypeVariablesErrorVariables :: Typed.TypedTerm Checking.UnboundTypeVariablesError -> Typed.TypedTerm (S.Set Core.Name) unboundTypeVariablesErrorVariables x = @@ -663,6 +699,11 @@ Core.projectionFieldName = (Core.Name "path")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UndefinedTermVariableCheckingError +undefinedTermVariableCheckingErrorUndefinedTermVariableCheckingError :: Typed.TypedName Checking.UndefinedTermVariableCheckingError +undefinedTermVariableCheckingErrorUndefinedTermVariableCheckingError = + Typed.TypedName (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError") + -- | DSL updater for the name field of hydra.error.checking.UndefinedTermVariableCheckingError undefinedTermVariableCheckingErrorWithName :: Typed.TypedTerm Checking.UndefinedTermVariableCheckingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Checking.UndefinedTermVariableCheckingError undefinedTermVariableCheckingErrorWithName original newVal = @@ -728,6 +769,10 @@ Core.projectionFieldName = (Core.Name "types")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UnequalTypesError +unequalTypesErrorUnequalTypesError :: Typed.TypedName Checking.UnequalTypesError +unequalTypesErrorUnequalTypesError = Typed.TypedName (Core.Name "hydra.error.checking.UnequalTypesError") + -- | DSL updater for the description field of hydra.error.checking.UnequalTypesError unequalTypesErrorWithDescription :: Typed.TypedTerm Checking.UnequalTypesError -> Typed.TypedTerm String -> Typed.TypedTerm Checking.UnequalTypesError unequalTypesErrorWithDescription original newVal = @@ -781,6 +826,11 @@ Core.projectionFieldName = (Core.Name "termVariant")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UnsupportedTermVariantError +unsupportedTermVariantErrorUnsupportedTermVariantError :: Typed.TypedName Checking.UnsupportedTermVariantError +unsupportedTermVariantErrorUnsupportedTermVariantError = + Typed.TypedName (Core.Name "hydra.error.checking.UnsupportedTermVariantError") + -- | DSL updater for the termVariant field of hydra.error.checking.UnsupportedTermVariantError unsupportedTermVariantErrorWithTermVariant :: Typed.TypedTerm Checking.UnsupportedTermVariantError -> Typed.TypedTerm Variants.TermVariant -> Typed.TypedTerm Checking.UnsupportedTermVariantError unsupportedTermVariantErrorWithTermVariant original newVal = @@ -798,6 +848,10 @@ Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"), Core.recordFields = []})) +-- | DSL name token for hydra.error.checking.UntypedLambdaError +untypedLambdaErrorUntypedLambdaError :: Typed.TypedName Checking.UntypedLambdaError +untypedLambdaErrorUntypedLambdaError = Typed.TypedName (Core.Name "hydra.error.checking.UntypedLambdaError") + -- | DSL constructor for hydra.error.checking.UntypedLetBindingError untypedLetBindingError :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Checking.UntypedLetBindingError untypedLetBindingError binding = @@ -817,6 +871,10 @@ Core.projectionFieldName = (Core.Name "binding")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.checking.UntypedLetBindingError +untypedLetBindingErrorUntypedLetBindingError :: Typed.TypedName Checking.UntypedLetBindingError +untypedLetBindingErrorUntypedLetBindingError = Typed.TypedName (Core.Name "hydra.error.checking.UntypedLetBindingError") + -- | DSL updater for the binding field of hydra.error.checking.UntypedLetBindingError untypedLetBindingErrorWithBinding :: Typed.TypedTerm Checking.UntypedLetBindingError -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm Checking.UntypedLetBindingError untypedLetBindingErrorWithBinding original newVal = @@ -857,6 +915,11 @@ Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"), Core.projectionFieldName = (Core.Name "path")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.error.checking.UntypedTermVariableCheckingError +untypedTermVariableCheckingErrorUntypedTermVariableCheckingError :: Typed.TypedName Checking.UntypedTermVariableCheckingError +untypedTermVariableCheckingErrorUntypedTermVariableCheckingError = + Typed.TypedName (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError") -- | DSL updater for the name field of hydra.error.checking.UntypedTermVariableCheckingError untypedTermVariableCheckingErrorWithName :: Typed.TypedTerm Checking.UntypedTermVariableCheckingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Checking.UntypedTermVariableCheckingError diff --git a/src/main/haskell/Hydra/Dsl/Error/Core.hs b/src/main/haskell/Hydra/Dsl/Error/Core.hs --- a/src/main/haskell/Hydra/Dsl/Error/Core.hs +++ b/src/main/haskell/Hydra/Dsl/Error/Core.hs @@ -5,9 +5,11 @@ module Hydra.Dsl.Error.Core where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Error.Core as DecodeErrorCore import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Paths as DslPaths import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Encode.Error.Core as EncodeErrorCore import qualified Hydra.Error.Core as ErrorCore import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed @@ -28,6 +30,10 @@ Core.fieldName = (Core.Name "value"), Core.fieldTerm = (Typed.unTypedTerm value)}]})) +-- | DSL name token for hydra.error.core.ConstantConditionError +constantConditionErrorConstantConditionError :: Typed.TypedName ErrorCore.ConstantConditionError +constantConditionErrorConstantConditionError = Typed.TypedName (Core.Name "hydra.error.core.ConstantConditionError") + -- | DSL accessor for the location field of hydra.error.core.ConstantConditionError constantConditionErrorLocation :: Typed.TypedTerm ErrorCore.ConstantConditionError -> Typed.TypedTerm Paths.SubtermPath constantConditionErrorLocation x = @@ -93,6 +99,10 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.DuplicateBindingError +duplicateBindingErrorDuplicateBindingError :: Typed.TypedName ErrorCore.DuplicateBindingError +duplicateBindingErrorDuplicateBindingError = Typed.TypedName (Core.Name "hydra.error.core.DuplicateBindingError") + -- | DSL accessor for the location field of hydra.error.core.DuplicateBindingError duplicateBindingErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateBindingError -> Typed.TypedTerm Paths.SubtermPath duplicateBindingErrorLocation x = @@ -158,6 +168,10 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.DuplicateFieldError +duplicateFieldErrorDuplicateFieldError :: Typed.TypedName ErrorCore.DuplicateFieldError +duplicateFieldErrorDuplicateFieldError = Typed.TypedName (Core.Name "hydra.error.core.DuplicateFieldError") + -- | DSL accessor for the location field of hydra.error.core.DuplicateFieldError duplicateFieldErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateFieldError -> Typed.TypedTerm Paths.SubtermPath duplicateFieldErrorLocation x = @@ -223,6 +237,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.DuplicateRecordTypeFieldNamesError +duplicateRecordTypeFieldNamesErrorDuplicateRecordTypeFieldNamesError :: Typed.TypedName ErrorCore.DuplicateRecordTypeFieldNamesError +duplicateRecordTypeFieldNamesErrorDuplicateRecordTypeFieldNamesError = + Typed.TypedName (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError") + -- | DSL accessor for the location field of hydra.error.core.DuplicateRecordTypeFieldNamesError duplicateRecordTypeFieldNamesErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError -> Typed.TypedTerm Paths.SubtermPath duplicateRecordTypeFieldNamesErrorLocation x = @@ -288,6 +307,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.DuplicateUnionTypeFieldNamesError +duplicateUnionTypeFieldNamesErrorDuplicateUnionTypeFieldNamesError :: Typed.TypedName ErrorCore.DuplicateUnionTypeFieldNamesError +duplicateUnionTypeFieldNamesErrorDuplicateUnionTypeFieldNamesError = + Typed.TypedName (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError") + -- | DSL accessor for the location field of hydra.error.core.DuplicateUnionTypeFieldNamesError duplicateUnionTypeFieldNamesErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError -> Typed.TypedTerm Paths.SubtermPath duplicateUnionTypeFieldNamesErrorLocation x = @@ -353,6 +377,10 @@ Core.fieldName = (Core.Name "typeName"), Core.fieldTerm = (Typed.unTypedTerm typeName)}]})) +-- | DSL name token for hydra.error.core.EmptyCaseStatementError +emptyCaseStatementErrorEmptyCaseStatementError :: Typed.TypedName ErrorCore.EmptyCaseStatementError +emptyCaseStatementErrorEmptyCaseStatementError = Typed.TypedName (Core.Name "hydra.error.core.EmptyCaseStatementError") + -- | DSL accessor for the location field of hydra.error.core.EmptyCaseStatementError emptyCaseStatementErrorLocation :: Typed.TypedTerm ErrorCore.EmptyCaseStatementError -> Typed.TypedTerm Paths.SubtermPath emptyCaseStatementErrorLocation x = @@ -415,6 +443,10 @@ Core.fieldName = (Core.Name "location"), Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyLetBindingsError +emptyLetBindingsErrorEmptyLetBindingsError :: Typed.TypedName ErrorCore.EmptyLetBindingsError +emptyLetBindingsErrorEmptyLetBindingsError = Typed.TypedName (Core.Name "hydra.error.core.EmptyLetBindingsError") + -- | DSL accessor for the location field of hydra.error.core.EmptyLetBindingsError emptyLetBindingsErrorLocation :: Typed.TypedTerm ErrorCore.EmptyLetBindingsError -> Typed.TypedTerm Paths.SubtermPath emptyLetBindingsErrorLocation x = @@ -444,6 +476,10 @@ Core.fieldName = (Core.Name "location"), Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyRecordTypeError +emptyRecordTypeErrorEmptyRecordTypeError :: Typed.TypedName ErrorCore.EmptyRecordTypeError +emptyRecordTypeErrorEmptyRecordTypeError = Typed.TypedName (Core.Name "hydra.error.core.EmptyRecordTypeError") + -- | DSL accessor for the location field of hydra.error.core.EmptyRecordTypeError emptyRecordTypeErrorLocation :: Typed.TypedTerm ErrorCore.EmptyRecordTypeError -> Typed.TypedTerm Paths.SubtermPath emptyRecordTypeErrorLocation x = @@ -473,6 +509,10 @@ Core.fieldName = (Core.Name "location"), Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyTermAnnotationError +emptyTermAnnotationErrorEmptyTermAnnotationError :: Typed.TypedName ErrorCore.EmptyTermAnnotationError +emptyTermAnnotationErrorEmptyTermAnnotationError = Typed.TypedName (Core.Name "hydra.error.core.EmptyTermAnnotationError") + -- | DSL accessor for the location field of hydra.error.core.EmptyTermAnnotationError emptyTermAnnotationErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTermAnnotationError -> Typed.TypedTerm Paths.SubtermPath emptyTermAnnotationErrorLocation x = @@ -502,6 +542,10 @@ Core.fieldName = (Core.Name "location"), Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyTypeAnnotationError +emptyTypeAnnotationErrorEmptyTypeAnnotationError :: Typed.TypedName ErrorCore.EmptyTypeAnnotationError +emptyTypeAnnotationErrorEmptyTypeAnnotationError = Typed.TypedName (Core.Name "hydra.error.core.EmptyTypeAnnotationError") + -- | DSL accessor for the location field of hydra.error.core.EmptyTypeAnnotationError emptyTypeAnnotationErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTypeAnnotationError -> Typed.TypedTerm Paths.SubtermPath emptyTypeAnnotationErrorLocation x = @@ -531,6 +575,10 @@ Core.fieldName = (Core.Name "location"), Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyTypeNameInTermError +emptyTypeNameInTermErrorEmptyTypeNameInTermError :: Typed.TypedName ErrorCore.EmptyTypeNameInTermError +emptyTypeNameInTermErrorEmptyTypeNameInTermError = Typed.TypedName (Core.Name "hydra.error.core.EmptyTypeNameInTermError") + -- | DSL accessor for the location field of hydra.error.core.EmptyTypeNameInTermError emptyTypeNameInTermErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTypeNameInTermError -> Typed.TypedTerm Paths.SubtermPath emptyTypeNameInTermErrorLocation x = @@ -560,6 +608,10 @@ Core.fieldName = (Core.Name "location"), Core.fieldTerm = (Typed.unTypedTerm location)}]})) +-- | DSL name token for hydra.error.core.EmptyUnionTypeError +emptyUnionTypeErrorEmptyUnionTypeError :: Typed.TypedName ErrorCore.EmptyUnionTypeError +emptyUnionTypeErrorEmptyUnionTypeError = Typed.TypedName (Core.Name "hydra.error.core.EmptyUnionTypeError") + -- | DSL accessor for the location field of hydra.error.core.EmptyUnionTypeError emptyUnionTypeErrorLocation :: Typed.TypedTerm ErrorCore.EmptyUnionTypeError -> Typed.TypedTerm Paths.SubtermPath emptyUnionTypeErrorLocation x = @@ -592,6 +644,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidForallParameterNameError +invalidForallParameterNameErrorInvalidForallParameterNameError :: Typed.TypedName ErrorCore.InvalidForallParameterNameError +invalidForallParameterNameErrorInvalidForallParameterNameError = + Typed.TypedName (Core.Name "hydra.error.core.InvalidForallParameterNameError") + -- | DSL accessor for the location field of hydra.error.core.InvalidForallParameterNameError invalidForallParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidForallParameterNameError -> Typed.TypedTerm Paths.SubtermPath invalidForallParameterNameErrorLocation x = @@ -657,6 +714,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidLambdaParameterNameError +invalidLambdaParameterNameErrorInvalidLambdaParameterNameError :: Typed.TypedName ErrorCore.InvalidLambdaParameterNameError +invalidLambdaParameterNameErrorInvalidLambdaParameterNameError = + Typed.TypedName (Core.Name "hydra.error.core.InvalidLambdaParameterNameError") + -- | DSL accessor for the location field of hydra.error.core.InvalidLambdaParameterNameError invalidLambdaParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError -> Typed.TypedTerm Paths.SubtermPath invalidLambdaParameterNameErrorLocation x = @@ -722,6 +784,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidLetBindingNameError +invalidLetBindingNameErrorInvalidLetBindingNameError :: Typed.TypedName ErrorCore.InvalidLetBindingNameError +invalidLetBindingNameErrorInvalidLetBindingNameError = + Typed.TypedName (Core.Name "hydra.error.core.InvalidLetBindingNameError") + -- | DSL accessor for the location field of hydra.error.core.InvalidLetBindingNameError invalidLetBindingNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidLetBindingNameError -> Typed.TypedTerm Paths.SubtermPath invalidLetBindingNameErrorLocation x = @@ -774,6 +841,10 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.error.core.InvalidLiteralError +invalidLiteralErrorInvalidLiteralError :: Typed.TypedName ErrorCore.InvalidLiteralError +invalidLiteralErrorInvalidLiteralError = Typed.TypedName (Core.Name "hydra.error.core.InvalidLiteralError") + -- | DSL injection for the typeMismatch variant of hydra.error.core.InvalidLiteralError invalidLiteralErrorTypeMismatch :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm ErrorCore.InvalidLiteralError invalidLiteralErrorTypeMismatch x = @@ -864,6 +935,10 @@ Core.fieldName = (Core.Name "invalidLetBindingName"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.error.core.InvalidTermError +invalidTermErrorInvalidTermError :: Typed.TypedName ErrorCore.InvalidTermError +invalidTermErrorInvalidTermError = Typed.TypedName (Core.Name "hydra.error.core.InvalidTermError") + -- | DSL injection for the invalidTypeLambdaParameterName variant of hydra.error.core.InvalidTermError invalidTermErrorInvalidTypeLambdaParameterName :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm ErrorCore.InvalidTermError invalidTermErrorInvalidTypeLambdaParameterName x = @@ -1035,6 +1110,10 @@ Core.fieldName = (Core.Name "invalidForallParameterName"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.error.core.InvalidTypeError +invalidTypeErrorInvalidTypeError :: Typed.TypedName ErrorCore.InvalidTypeError +invalidTypeErrorInvalidTypeError = Typed.TypedName (Core.Name "hydra.error.core.InvalidTypeError") + -- | DSL injection for the invalidTypeSchemeVariableName variant of hydra.error.core.InvalidTypeError invalidTypeErrorInvalidTypeSchemeVariableName :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm ErrorCore.InvalidTypeError invalidTypeErrorInvalidTypeSchemeVariableName x = @@ -1120,6 +1199,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidTypeLambdaParameterNameError +invalidTypeLambdaParameterNameErrorInvalidTypeLambdaParameterNameError :: Typed.TypedName ErrorCore.InvalidTypeLambdaParameterNameError +invalidTypeLambdaParameterNameErrorInvalidTypeLambdaParameterNameError = + Typed.TypedName (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError") + -- | DSL accessor for the location field of hydra.error.core.InvalidTypeLambdaParameterNameError invalidTypeLambdaParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm Paths.SubtermPath invalidTypeLambdaParameterNameErrorLocation x = @@ -1185,6 +1269,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.core.InvalidTypeSchemeVariableNameError +invalidTypeSchemeVariableNameErrorInvalidTypeSchemeVariableNameError :: Typed.TypedName ErrorCore.InvalidTypeSchemeVariableNameError +invalidTypeSchemeVariableNameErrorInvalidTypeSchemeVariableNameError = + Typed.TypedName (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError") + -- | DSL accessor for the location field of hydra.error.core.InvalidTypeSchemeVariableNameError invalidTypeSchemeVariableNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm Paths.SubtermPath invalidTypeSchemeVariableNameErrorLocation x = @@ -1268,6 +1357,10 @@ Core.projectionFieldName = (Core.Name "expectedType")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.LiteralTypeMismatchError +literalTypeMismatchErrorLiteralTypeMismatchError :: Typed.TypedName ErrorCore.LiteralTypeMismatchError +literalTypeMismatchErrorLiteralTypeMismatchError = Typed.TypedName (Core.Name "hydra.error.core.LiteralTypeMismatchError") + -- | DSL updater for the actualType field of hydra.error.core.LiteralTypeMismatchError literalTypeMismatchErrorWithActualType :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm ErrorCore.LiteralTypeMismatchError literalTypeMismatchErrorWithActualType original newVal = @@ -1321,6 +1414,11 @@ Core.projectionFieldName = (Core.Name "location")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.NestedTermAnnotationError +nestedTermAnnotationErrorNestedTermAnnotationError :: Typed.TypedName ErrorCore.NestedTermAnnotationError +nestedTermAnnotationErrorNestedTermAnnotationError = + Typed.TypedName (Core.Name "hydra.error.core.NestedTermAnnotationError") + -- | DSL updater for the location field of hydra.error.core.NestedTermAnnotationError nestedTermAnnotationErrorWithLocation :: Typed.TypedTerm ErrorCore.NestedTermAnnotationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTermAnnotationError nestedTermAnnotationErrorWithLocation original newVal = @@ -1350,6 +1448,11 @@ Core.projectionFieldName = (Core.Name "location")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.NestedTypeAnnotationError +nestedTypeAnnotationErrorNestedTypeAnnotationError :: Typed.TypedName ErrorCore.NestedTypeAnnotationError +nestedTypeAnnotationErrorNestedTypeAnnotationError = + Typed.TypedName (Core.Name "hydra.error.core.NestedTypeAnnotationError") + -- | DSL updater for the location field of hydra.error.core.NestedTypeAnnotationError nestedTypeAnnotationErrorWithLocation :: Typed.TypedTerm ErrorCore.NestedTypeAnnotationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTypeAnnotationError nestedTypeAnnotationErrorWithLocation original newVal = @@ -1391,6 +1494,11 @@ Core.projectionFieldName = (Core.Name "location")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.NonComparableMapKeyTypeError +nonComparableMapKeyTypeErrorNonComparableMapKeyTypeError :: Typed.TypedName ErrorCore.NonComparableMapKeyTypeError +nonComparableMapKeyTypeErrorNonComparableMapKeyTypeError = + Typed.TypedName (Core.Name "hydra.error.core.NonComparableMapKeyTypeError") + -- | DSL updater for the keyType field of hydra.error.core.NonComparableMapKeyTypeError nonComparableMapKeyTypeErrorWithKeyType :: Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError nonComparableMapKeyTypeErrorWithKeyType original newVal = @@ -1456,6 +1564,11 @@ Core.projectionFieldName = (Core.Name "location")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.NonComparableSetElementTypeError +nonComparableSetElementTypeErrorNonComparableSetElementTypeError :: Typed.TypedName ErrorCore.NonComparableSetElementTypeError +nonComparableSetElementTypeErrorNonComparableSetElementTypeError = + Typed.TypedName (Core.Name "hydra.error.core.NonComparableSetElementTypeError") + -- | DSL updater for the elementType field of hydra.error.core.NonComparableSetElementTypeError nonComparableSetElementTypeErrorWithElementType :: Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError nonComparableSetElementTypeErrorWithElementType original newVal = @@ -1512,6 +1625,10 @@ Core.projectionFieldName = (Core.Name "location")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.RedundantWrapUnwrapError +redundantWrapUnwrapErrorRedundantWrapUnwrapError :: Typed.TypedName ErrorCore.RedundantWrapUnwrapError +redundantWrapUnwrapErrorRedundantWrapUnwrapError = Typed.TypedName (Core.Name "hydra.error.core.RedundantWrapUnwrapError") + -- | DSL accessor for the typeName field of hydra.error.core.RedundantWrapUnwrapError redundantWrapUnwrapErrorTypeName :: Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError -> Typed.TypedTerm Core.Name redundantWrapUnwrapErrorTypeName x = @@ -1586,6 +1703,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.SelfApplicationError +selfApplicationErrorSelfApplicationError :: Typed.TypedName ErrorCore.SelfApplicationError +selfApplicationErrorSelfApplicationError = Typed.TypedName (Core.Name "hydra.error.core.SelfApplicationError") + -- | DSL updater for the location field of hydra.error.core.SelfApplicationError selfApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.SelfApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.SelfApplicationError selfApplicationErrorWithLocation original newVal = @@ -1651,6 +1772,10 @@ Core.projectionFieldName = (Core.Name "location")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.SingleVariantUnionError +singleVariantUnionErrorSingleVariantUnionError :: Typed.TypedName ErrorCore.SingleVariantUnionError +singleVariantUnionErrorSingleVariantUnionError = Typed.TypedName (Core.Name "hydra.error.core.SingleVariantUnionError") + -- | DSL updater for the fieldName field of hydra.error.core.SingleVariantUnionError singleVariantUnionErrorWithFieldName :: Typed.TypedTerm ErrorCore.SingleVariantUnionError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.SingleVariantUnionError singleVariantUnionErrorWithFieldName original newVal = @@ -1716,6 +1841,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.TermVariableShadowingError +termVariableShadowingErrorTermVariableShadowingError :: Typed.TypedName ErrorCore.TermVariableShadowingError +termVariableShadowingErrorTermVariableShadowingError = + Typed.TypedName (Core.Name "hydra.error.core.TermVariableShadowingError") + -- | DSL updater for the location field of hydra.error.core.TermVariableShadowingError termVariableShadowingErrorWithLocation :: Typed.TypedTerm ErrorCore.TermVariableShadowingError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TermVariableShadowingError termVariableShadowingErrorWithLocation original newVal = @@ -1781,6 +1911,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.TypeVariableShadowingInForallError +typeVariableShadowingInForallErrorTypeVariableShadowingInForallError :: Typed.TypedName ErrorCore.TypeVariableShadowingInForallError +typeVariableShadowingInForallErrorTypeVariableShadowingInForallError = + Typed.TypedName (Core.Name "hydra.error.core.TypeVariableShadowingInForallError") + -- | DSL updater for the location field of hydra.error.core.TypeVariableShadowingInForallError typeVariableShadowingInForallErrorWithLocation :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError typeVariableShadowingInForallErrorWithLocation original newVal = @@ -1846,6 +1981,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.TypeVariableShadowingInTypeLambdaError +typeVariableShadowingInTypeLambdaErrorTypeVariableShadowingInTypeLambdaError :: Typed.TypedName ErrorCore.TypeVariableShadowingInTypeLambdaError +typeVariableShadowingInTypeLambdaErrorTypeVariableShadowingInTypeLambdaError = + Typed.TypedName (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError") + -- | DSL updater for the location field of hydra.error.core.TypeVariableShadowingInTypeLambdaError typeVariableShadowingInTypeLambdaErrorWithLocation :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError typeVariableShadowingInTypeLambdaErrorWithLocation original newVal = @@ -1911,6 +2051,10 @@ Core.projectionFieldName = (Core.Name "typeName")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedFieldError +undefinedFieldErrorUndefinedFieldError :: Typed.TypedName ErrorCore.UndefinedFieldError +undefinedFieldErrorUndefinedFieldError = Typed.TypedName (Core.Name "hydra.error.core.UndefinedFieldError") + -- | DSL updater for the fieldName field of hydra.error.core.UndefinedFieldError undefinedFieldErrorWithFieldName :: Typed.TypedTerm ErrorCore.UndefinedFieldError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedFieldError undefinedFieldErrorWithFieldName original newVal = @@ -1976,6 +2120,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTermVariableError +undefinedTermVariableErrorUndefinedTermVariableError :: Typed.TypedName ErrorCore.UndefinedTermVariableError +undefinedTermVariableErrorUndefinedTermVariableError = + Typed.TypedName (Core.Name "hydra.error.core.UndefinedTermVariableError") + -- | DSL updater for the location field of hydra.error.core.UndefinedTermVariableError undefinedTermVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTermVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTermVariableError undefinedTermVariableErrorWithLocation original newVal = @@ -2041,6 +2190,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTypeVariableError +undefinedTypeVariableErrorUndefinedTypeVariableError :: Typed.TypedName ErrorCore.UndefinedTypeVariableError +undefinedTypeVariableErrorUndefinedTypeVariableError = + Typed.TypedName (Core.Name "hydra.error.core.UndefinedTypeVariableError") + -- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableError undefinedTypeVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableError undefinedTypeVariableErrorWithLocation original newVal = @@ -2106,6 +2260,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTypeVariableInBindingTypeError +undefinedTypeVariableInBindingTypeErrorUndefinedTypeVariableInBindingTypeError :: Typed.TypedName ErrorCore.UndefinedTypeVariableInBindingTypeError +undefinedTypeVariableInBindingTypeErrorUndefinedTypeVariableInBindingTypeError = + Typed.TypedName (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError") + -- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInBindingTypeError undefinedTypeVariableInBindingTypeErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError undefinedTypeVariableInBindingTypeErrorWithLocation original newVal = @@ -2171,6 +2330,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTypeVariableInLambdaDomainError +undefinedTypeVariableInLambdaDomainErrorUndefinedTypeVariableInLambdaDomainError :: Typed.TypedName ErrorCore.UndefinedTypeVariableInLambdaDomainError +undefinedTypeVariableInLambdaDomainErrorUndefinedTypeVariableInLambdaDomainError = + Typed.TypedName (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError") + -- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInLambdaDomainError undefinedTypeVariableInLambdaDomainErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError undefinedTypeVariableInLambdaDomainErrorWithLocation original newVal = @@ -2236,6 +2400,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UndefinedTypeVariableInTypeApplicationError +undefinedTypeVariableInTypeApplicationErrorUndefinedTypeVariableInTypeApplicationError :: Typed.TypedName ErrorCore.UndefinedTypeVariableInTypeApplicationError +undefinedTypeVariableInTypeApplicationErrorUndefinedTypeVariableInTypeApplicationError = + Typed.TypedName (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError") + -- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInTypeApplicationError undefinedTypeVariableInTypeApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError undefinedTypeVariableInTypeApplicationErrorWithLocation original newVal = @@ -2301,6 +2470,11 @@ Core.projectionFieldName = (Core.Name "expectedVariant")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UnexpectedTermVariantError +unexpectedTermVariantErrorUnexpectedTermVariantError :: Typed.TypedName ErrorCore.UnexpectedTermVariantError +unexpectedTermVariantErrorUnexpectedTermVariantError = + Typed.TypedName (Core.Name "hydra.error.core.UnexpectedTermVariantError") + -- | DSL updater for the actualTerm field of hydra.error.core.UnexpectedTermVariantError unexpectedTermVariantErrorWithActualTerm :: Typed.TypedTerm ErrorCore.UnexpectedTermVariantError -> Typed.TypedTerm Core.Term -> Typed.TypedTerm ErrorCore.UnexpectedTermVariantError unexpectedTermVariantErrorWithActualTerm original newVal = @@ -2366,6 +2540,11 @@ Core.projectionFieldName = (Core.Name "expectedVariant")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UnexpectedTypeVariantError +unexpectedTypeVariantErrorUnexpectedTypeVariantError :: Typed.TypedName ErrorCore.UnexpectedTypeVariantError +unexpectedTypeVariantErrorUnexpectedTypeVariantError = + Typed.TypedName (Core.Name "hydra.error.core.UnexpectedTypeVariantError") + -- | DSL updater for the actualType field of hydra.error.core.UnexpectedTypeVariantError unexpectedTypeVariantErrorWithActualType :: Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError unexpectedTypeVariantErrorWithActualType original newVal = @@ -2431,6 +2610,11 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UnknownPrimitiveNameError +unknownPrimitiveNameErrorUnknownPrimitiveNameError :: Typed.TypedName ErrorCore.UnknownPrimitiveNameError +unknownPrimitiveNameErrorUnknownPrimitiveNameError = + Typed.TypedName (Core.Name "hydra.error.core.UnknownPrimitiveNameError") + -- | DSL updater for the location field of hydra.error.core.UnknownPrimitiveNameError unknownPrimitiveNameErrorWithLocation :: Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError unknownPrimitiveNameErrorWithLocation original newVal = @@ -2484,6 +2668,11 @@ Core.projectionFieldName = (Core.Name "location")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UnnecessaryIdentityApplicationError +unnecessaryIdentityApplicationErrorUnnecessaryIdentityApplicationError :: Typed.TypedName ErrorCore.UnnecessaryIdentityApplicationError +unnecessaryIdentityApplicationErrorUnnecessaryIdentityApplicationError = + Typed.TypedName (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError") + -- | DSL updater for the location field of hydra.error.core.UnnecessaryIdentityApplicationError unnecessaryIdentityApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError unnecessaryIdentityApplicationErrorWithLocation original newVal = @@ -2525,6 +2714,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.core.UntypedTermVariableError +untypedTermVariableErrorUntypedTermVariableError :: Typed.TypedName ErrorCore.UntypedTermVariableError +untypedTermVariableErrorUntypedTermVariableError = Typed.TypedName (Core.Name "hydra.error.core.UntypedTermVariableError") + -- | DSL updater for the location field of hydra.error.core.UntypedTermVariableError untypedTermVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UntypedTermVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UntypedTermVariableError untypedTermVariableErrorWithLocation original newVal = @@ -2577,6 +2770,11 @@ Core.projectionTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"), Core.projectionFieldName = (Core.Name "location")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.error.core.VoidInNonBottomPositionError +voidInNonBottomPositionErrorVoidInNonBottomPositionError :: Typed.TypedName ErrorCore.VoidInNonBottomPositionError +voidInNonBottomPositionErrorVoidInNonBottomPositionError = + Typed.TypedName (Core.Name "hydra.error.core.VoidInNonBottomPositionError") -- | DSL updater for the location field of hydra.error.core.VoidInNonBottomPositionError voidInNonBottomPositionErrorWithLocation :: Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError diff --git a/src/main/haskell/Hydra/Dsl/Error/File.hs b/src/main/haskell/Hydra/Dsl/Error/File.hs --- a/src/main/haskell/Hydra/Dsl/Error/File.hs +++ b/src/main/haskell/Hydra/Dsl/Error/File.hs @@ -5,7 +5,9 @@ module Hydra.Dsl.Error.File where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Error.File as DecodeErrorFile import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Encode.Error.File as EncodeErrorFile import qualified Hydra.Error.File as ErrorFile import qualified Hydra.File as File import qualified Hydra.Typed as Typed @@ -20,6 +22,10 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "alreadyExists"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.error.file.FileError +fileErrorFileError :: Typed.TypedName ErrorFile.FileError +fileErrorFileError = Typed.TypedName (Core.Name "hydra.error.file.FileError") -- | DSL injection for the invalidPath variant of hydra.error.file.FileError fileErrorInvalidPath :: Typed.TypedTerm String -> Typed.TypedTerm ErrorFile.FileError diff --git a/src/main/haskell/Hydra/Dsl/Error/Packaging.hs b/src/main/haskell/Hydra/Dsl/Error/Packaging.hs --- a/src/main/haskell/Hydra/Dsl/Error/Packaging.hs +++ b/src/main/haskell/Hydra/Dsl/Error/Packaging.hs @@ -5,9 +5,11 @@ module Hydra.Dsl.Error.Packaging where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Error.Packaging as DecodeErrorPackaging import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Packaging as DslPackaging import qualified Hydra.Dsl.Util as DslUtil +import qualified Hydra.Encode.Error.Packaging as EncodeErrorPackaging import qualified Hydra.Error.Packaging as ErrorPackaging import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed @@ -28,6 +30,11 @@ Core.fieldName = (Core.Name "second"), Core.fieldTerm = (Typed.unTypedTerm second)}]})) +-- | DSL name token for hydra.error.packaging.ConflictingModuleNameError +conflictingModuleNameErrorConflictingModuleNameError :: Typed.TypedName ErrorPackaging.ConflictingModuleNameError +conflictingModuleNameErrorConflictingModuleNameError = + Typed.TypedName (Core.Name "hydra.error.packaging.ConflictingModuleNameError") + -- | DSL accessor for the first field of hydra.error.packaging.ConflictingModuleNameError conflictingModuleNameErrorFirst :: Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError -> Typed.TypedTerm Packaging.ModuleName conflictingModuleNameErrorFirst x = @@ -108,6 +115,11 @@ Core.projectionFieldName = (Core.Name "conflictingName")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.packaging.ConflictingVariantNameError +conflictingVariantNameErrorConflictingVariantNameError :: Typed.TypedName ErrorPackaging.ConflictingVariantNameError +conflictingVariantNameErrorConflictingVariantNameError = + Typed.TypedName (Core.Name "hydra.error.packaging.ConflictingVariantNameError") + -- | DSL accessor for the moduleName field of hydra.error.packaging.ConflictingVariantNameError conflictingVariantNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Packaging.ModuleName conflictingVariantNameErrorModuleName x = @@ -272,6 +284,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.packaging.DefinitionNotInModuleNameError +definitionNotInModuleNameErrorDefinitionNotInModuleNameError :: Typed.TypedName ErrorPackaging.DefinitionNotInModuleNameError +definitionNotInModuleNameErrorDefinitionNotInModuleNameError = + Typed.TypedName (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError") + -- | DSL accessor for the moduleName field of hydra.error.packaging.DefinitionNotInModuleNameError definitionNotInModuleNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError -> Typed.TypedTerm Packaging.ModuleName definitionNotInModuleNameErrorModuleName x = @@ -340,6 +357,11 @@ Core.fieldName = (Core.Name "followingName"), Core.fieldTerm = (Typed.unTypedTerm followingName)}]})) +-- | DSL name token for hydra.error.packaging.DefinitionsOutOfOrderError +definitionsOutOfOrderErrorDefinitionsOutOfOrderError :: Typed.TypedName ErrorPackaging.DefinitionsOutOfOrderError +definitionsOutOfOrderErrorDefinitionsOutOfOrderError = + Typed.TypedName (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError") + -- | DSL accessor for the followingName field of hydra.error.packaging.DefinitionsOutOfOrderError definitionsOutOfOrderErrorFollowingName :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm Core.Name definitionsOutOfOrderErrorFollowingName x = @@ -452,6 +474,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.packaging.DuplicateDefinitionNameError +duplicateDefinitionNameErrorDuplicateDefinitionNameError :: Typed.TypedName ErrorPackaging.DuplicateDefinitionNameError +duplicateDefinitionNameErrorDuplicateDefinitionNameError = + Typed.TypedName (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError") + -- | DSL accessor for the moduleName field of hydra.error.packaging.DuplicateDefinitionNameError duplicateDefinitionNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError -> Typed.TypedTerm Packaging.ModuleName duplicateDefinitionNameErrorModuleName x = @@ -514,6 +541,11 @@ Core.fieldName = (Core.Name "moduleName"), Core.fieldTerm = (Typed.unTypedTerm moduleName)}]})) +-- | DSL name token for hydra.error.packaging.DuplicateModuleNameError +duplicateModuleNameErrorDuplicateModuleNameError :: Typed.TypedName ErrorPackaging.DuplicateModuleNameError +duplicateModuleNameErrorDuplicateModuleNameError = + Typed.TypedName (Core.Name "hydra.error.packaging.DuplicateModuleNameError") + -- | DSL accessor for the moduleName field of hydra.error.packaging.DuplicateModuleNameError duplicateModuleNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateModuleNameError -> Typed.TypedTerm Packaging.ModuleName duplicateModuleNameErrorModuleName x = @@ -558,6 +590,11 @@ Core.projectionFieldName = (Core.Name "expectedConvention")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.error.packaging.InvalidDefinitionNameError +invalidDefinitionNameErrorInvalidDefinitionNameError :: Typed.TypedName ErrorPackaging.InvalidDefinitionNameError +invalidDefinitionNameErrorInvalidDefinitionNameError = + Typed.TypedName (Core.Name "hydra.error.packaging.InvalidDefinitionNameError") + -- | DSL accessor for the moduleName field of hydra.error.packaging.InvalidDefinitionNameError invalidDefinitionNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm Packaging.ModuleName invalidDefinitionNameErrorModuleName x = @@ -693,6 +730,10 @@ Core.fieldName = (Core.Name "invalidDefinitionName"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.error.packaging.InvalidModuleError +invalidModuleErrorInvalidModuleError :: Typed.TypedName ErrorPackaging.InvalidModuleError +invalidModuleErrorInvalidModuleError = Typed.TypedName (Core.Name "hydra.error.packaging.InvalidModuleError") + -- | DSL injection for the invalidModuleNameConvention variant of hydra.error.packaging.InvalidModuleError invalidModuleErrorInvalidModuleNameConvention :: Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError invalidModuleErrorInvalidModuleNameConvention x = @@ -721,6 +762,11 @@ Core.fieldName = (Core.Name "moduleName"), Core.fieldTerm = (Typed.unTypedTerm moduleName)}]})) +-- | DSL name token for hydra.error.packaging.InvalidModuleNameConventionError +invalidModuleNameConventionErrorInvalidModuleNameConventionError :: Typed.TypedName ErrorPackaging.InvalidModuleNameConventionError +invalidModuleNameConventionErrorInvalidModuleNameConventionError = + Typed.TypedName (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError") + -- | DSL accessor for the moduleName field of hydra.error.packaging.InvalidModuleNameConventionError invalidModuleNameConventionErrorModuleName :: Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError -> Typed.TypedTerm Packaging.ModuleName invalidModuleNameConventionErrorModuleName x = @@ -767,6 +813,10 @@ Core.fieldName = (Core.Name "invalidModule"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.error.packaging.InvalidPackageError +invalidPackageErrorInvalidPackageError :: Typed.TypedName ErrorPackaging.InvalidPackageError +invalidPackageErrorInvalidPackageError = Typed.TypedName (Core.Name "hydra.error.packaging.InvalidPackageError") + -- | DSL injection for the invalidPackageName variant of hydra.error.packaging.InvalidPackageError invalidPackageErrorInvalidPackageName :: Typed.TypedTerm ErrorPackaging.InvalidPackageNameError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError invalidPackageErrorInvalidPackageName x = @@ -776,6 +826,15 @@ Core.fieldName = (Core.Name "invalidPackageName"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL injection for the undeclaredDependency variant of hydra.error.packaging.InvalidPackageError +invalidPackageErrorUndeclaredDependency :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError +invalidPackageErrorUndeclaredDependency x = + Typed.TypedTerm (Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "undeclaredDependency"), + Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for hydra.error.packaging.InvalidPackageNameError invalidPackageNameError :: Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm ErrorPackaging.InvalidPackageNameError invalidPackageNameError packageName = @@ -786,6 +845,11 @@ Core.fieldName = (Core.Name "packageName"), Core.fieldTerm = (Typed.unTypedTerm packageName)}]})) +-- | DSL name token for hydra.error.packaging.InvalidPackageNameError +invalidPackageNameErrorInvalidPackageNameError :: Typed.TypedName ErrorPackaging.InvalidPackageNameError +invalidPackageNameErrorInvalidPackageNameError = + Typed.TypedName (Core.Name "hydra.error.packaging.InvalidPackageNameError") + -- | DSL accessor for the packageName field of hydra.error.packaging.InvalidPackageNameError invalidPackageNameErrorPackageName :: Typed.TypedTerm ErrorPackaging.InvalidPackageNameError -> Typed.TypedTerm Packaging.PackageName invalidPackageNameErrorPackageName x = @@ -818,6 +882,11 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.error.packaging.MissingDocumentationError +missingDocumentationErrorMissingDocumentationError :: Typed.TypedName ErrorPackaging.MissingDocumentationError +missingDocumentationErrorMissingDocumentationError = + Typed.TypedName (Core.Name "hydra.error.packaging.MissingDocumentationError") + -- | DSL accessor for the moduleName field of hydra.error.packaging.MissingDocumentationError missingDocumentationErrorModuleName :: Typed.TypedTerm ErrorPackaging.MissingDocumentationError -> Typed.TypedTerm Packaging.ModuleName missingDocumentationErrorModuleName x = @@ -869,3 +938,123 @@ Core.Field { Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL constructor for hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError +undeclaredDependencyError moduleName referencedName owningModuleName = + Typed.TypedTerm (Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (Typed.unTypedTerm moduleName)}, + Core.Field { + Core.fieldName = (Core.Name "referencedName"), + Core.fieldTerm = (Typed.unTypedTerm referencedName)}, + Core.Field { + Core.fieldName = (Core.Name "owningModuleName"), + Core.fieldTerm = (Typed.unTypedTerm owningModuleName)}]})) + +-- | DSL accessor for the moduleName field of hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyErrorModuleName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Packaging.ModuleName +undeclaredDependencyErrorModuleName x = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "moduleName")})), + Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the owningModuleName field of hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyErrorOwningModuleName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Packaging.ModuleName +undeclaredDependencyErrorOwningModuleName x = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "owningModuleName")})), + Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL accessor for the referencedName field of hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyErrorReferencedName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Core.Name +undeclaredDependencyErrorReferencedName x = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "referencedName")})), + Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyErrorUndeclaredDependencyError :: Typed.TypedName ErrorPackaging.UndeclaredDependencyError +undeclaredDependencyErrorUndeclaredDependencyError = + Typed.TypedName (Core.Name "hydra.error.packaging.UndeclaredDependencyError") + +-- | DSL updater for the moduleName field of hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError +undeclaredDependencyErrorWithModuleName original newVal = + Typed.TypedTerm (Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (Typed.unTypedTerm newVal)}, + Core.Field { + Core.fieldName = (Core.Name "referencedName"), + Core.fieldTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "referencedName")})), + Core.applicationArgument = (Typed.unTypedTerm original)}))}, + Core.Field { + Core.fieldName = (Core.Name "owningModuleName"), + Core.fieldTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "owningModuleName")})), + Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + +-- | DSL updater for the owningModuleName field of hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyErrorWithOwningModuleName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError +undeclaredDependencyErrorWithOwningModuleName original newVal = + Typed.TypedTerm (Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "moduleName")})), + Core.applicationArgument = (Typed.unTypedTerm original)}))}, + Core.Field { + Core.fieldName = (Core.Name "referencedName"), + Core.fieldTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "referencedName")})), + Core.applicationArgument = (Typed.unTypedTerm original)}))}, + Core.Field { + Core.fieldName = (Core.Name "owningModuleName"), + Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + +-- | DSL updater for the referencedName field of hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyErrorWithReferencedName :: Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.UndeclaredDependencyError +undeclaredDependencyErrorWithReferencedName original newVal = + Typed.TypedTerm (Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "moduleName")})), + Core.applicationArgument = (Typed.unTypedTerm original)}))}, + Core.Field { + Core.fieldName = (Core.Name "referencedName"), + Core.fieldTerm = (Typed.unTypedTerm newVal)}, + Core.Field { + Core.fieldName = (Core.Name "owningModuleName"), + Core.fieldTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermProject (Core.Projection { + Core.projectionTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.projectionFieldName = (Core.Name "owningModuleName")})), + Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Error/System.hs b/src/main/haskell/Hydra/Dsl/Error/System.hs --- a/src/main/haskell/Hydra/Dsl/Error/System.hs +++ b/src/main/haskell/Hydra/Dsl/Error/System.hs @@ -5,7 +5,9 @@ module Hydra.Dsl.Error.System where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Error.System as DecodeErrorSystem import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Encode.Error.System as EncodeErrorSystem import qualified Hydra.Error.System as System import qualified Hydra.File as File import qualified Hydra.Typed as Typed @@ -56,3 +58,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "permissionDenied"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.error.system.SystemError +systemErrorSystemError :: Typed.TypedName System.SystemError +systemErrorSystemError = Typed.TypedName (Core.Name "hydra.error.system.SystemError") diff --git a/src/main/haskell/Hydra/Dsl/Errors.hs b/src/main/haskell/Hydra/Dsl/Errors.hs --- a/src/main/haskell/Hydra/Dsl/Errors.hs +++ b/src/main/haskell/Hydra/Dsl/Errors.hs @@ -5,12 +5,14 @@ module Hydra.Dsl.Errors where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Errors as DecodeErrors 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.Paths as DslPaths import qualified Hydra.Dsl.Typing as DslTyping import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Encode.Errors as EncodeErrors import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore import qualified Hydra.Errors as Errors @@ -28,6 +30,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.DecodingError +decodingErrorDecodingError :: Typed.TypedName Errors.DecodingError +decodingErrorDecodingError = Typed.TypedName (Core.Name "hydra.errors.DecodingError") + -- | DSL injection for the checking variant of hydra.errors.Error errorChecking :: Typed.TypedTerm Checking.CheckingError -> Typed.TypedTerm Errors.Error errorChecking x = @@ -64,6 +70,10 @@ Core.fieldName = (Core.Name "duplicateField"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.errors.Error +errorError :: Typed.TypedName Errors.Error +errorError = Typed.TypedName (Core.Name "hydra.errors.Error") + -- | DSL injection for the extraction variant of hydra.errors.Error errorExtraction :: Typed.TypedTerm Errors.ExtractionError -> Typed.TypedTerm Errors.Error errorExtraction x = @@ -172,6 +182,10 @@ Core.fieldName = (Core.Name "emptyList"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.errors.ExtractionError +extractionErrorExtractionError :: Typed.TypedName Errors.ExtractionError +extractionErrorExtractionError = Typed.TypedName (Core.Name "hydra.errors.ExtractionError") + -- | DSL injection for the multipleBindings variant of hydra.errors.ExtractionError extractionErrorMultipleBindings :: Typed.TypedTerm Errors.MultipleBindingsError -> Typed.TypedTerm Errors.ExtractionError extractionErrorMultipleBindings x = @@ -235,6 +249,10 @@ Core.fieldName = (Core.Name "checking"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.errors.InferenceError +inferenceErrorInferenceError :: Typed.TypedName Errors.InferenceError +inferenceErrorInferenceError = Typed.TypedName (Core.Name "hydra.errors.InferenceError") + -- | DSL injection for the other variant of hydra.errors.InferenceError inferenceErrorOther :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm Errors.InferenceError inferenceErrorOther x = @@ -263,6 +281,10 @@ Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm name)}]})) +-- | DSL name token for hydra.errors.MultipleBindingsError +multipleBindingsErrorMultipleBindingsError :: Typed.TypedName Errors.MultipleBindingsError +multipleBindingsErrorMultipleBindingsError = Typed.TypedName (Core.Name "hydra.errors.MultipleBindingsError") + -- | DSL accessor for the name field of hydra.errors.MultipleBindingsError multipleBindingsErrorName :: Typed.TypedTerm Errors.MultipleBindingsError -> Typed.TypedTerm Core.Name multipleBindingsErrorName x = @@ -301,6 +323,10 @@ Core.projectionFieldName = (Core.Name "fieldName")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.MultipleFieldsError +multipleFieldsErrorMultipleFieldsError :: Typed.TypedName Errors.MultipleFieldsError +multipleFieldsErrorMultipleFieldsError = Typed.TypedName (Core.Name "hydra.errors.MultipleFieldsError") + -- | DSL updater for the fieldName field of hydra.errors.MultipleFieldsError multipleFieldsErrorWithFieldName :: Typed.TypedTerm Errors.MultipleFieldsError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.MultipleFieldsError multipleFieldsErrorWithFieldName original newVal = @@ -330,6 +356,10 @@ Core.projectionFieldName = (Core.Name "fieldName")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.NoMatchingFieldError +noMatchingFieldErrorNoMatchingFieldError :: Typed.TypedName Errors.NoMatchingFieldError +noMatchingFieldErrorNoMatchingFieldError = Typed.TypedName (Core.Name "hydra.errors.NoMatchingFieldError") + -- | DSL updater for the fieldName field of hydra.errors.NoMatchingFieldError noMatchingFieldErrorWithFieldName :: Typed.TypedTerm Errors.NoMatchingFieldError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoMatchingFieldError noMatchingFieldErrorWithFieldName original newVal = @@ -359,6 +389,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.NoSuchBindingError +noSuchBindingErrorNoSuchBindingError :: Typed.TypedName Errors.NoSuchBindingError +noSuchBindingErrorNoSuchBindingError = Typed.TypedName (Core.Name "hydra.errors.NoSuchBindingError") + -- | DSL updater for the name field of hydra.errors.NoSuchBindingError noSuchBindingErrorWithName :: Typed.TypedTerm Errors.NoSuchBindingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoSuchBindingError noSuchBindingErrorWithName original newVal = @@ -388,6 +422,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.NoSuchPrimitiveError +noSuchPrimitiveErrorNoSuchPrimitiveError :: Typed.TypedName Errors.NoSuchPrimitiveError +noSuchPrimitiveErrorNoSuchPrimitiveError = Typed.TypedName (Core.Name "hydra.errors.NoSuchPrimitiveError") + -- | DSL updater for the name field of hydra.errors.NoSuchPrimitiveError noSuchPrimitiveErrorWithName :: Typed.TypedTerm Errors.NoSuchPrimitiveError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoSuchPrimitiveError noSuchPrimitiveErrorWithName original newVal = @@ -405,6 +443,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.OtherError +otherErrorOtherError :: Typed.TypedName Errors.OtherError +otherErrorOtherError = Typed.TypedName (Core.Name "hydra.errors.OtherError") + -- | DSL constructor for hydra.errors.OtherInferenceError otherInferenceError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm String -> Typed.TypedTerm Errors.OtherInferenceError otherInferenceError path message = @@ -427,6 +469,10 @@ Core.projectionFieldName = (Core.Name "message")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.OtherInferenceError +otherInferenceErrorOtherInferenceError :: Typed.TypedName Errors.OtherInferenceError +otherInferenceErrorOtherInferenceError = Typed.TypedName (Core.Name "hydra.errors.OtherInferenceError") + -- | DSL accessor for the path field of hydra.errors.OtherInferenceError otherInferenceErrorPath :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm Paths.SubtermPath otherInferenceErrorPath x = @@ -477,6 +523,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherResolutionError"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.OtherResolutionError +otherResolutionErrorOtherResolutionError :: Typed.TypedName Errors.OtherResolutionError +otherResolutionErrorOtherResolutionError = Typed.TypedName (Core.Name "hydra.errors.OtherResolutionError") + -- | DSL injection for the noMatchingField variant of hydra.errors.ResolutionError resolutionErrorNoMatchingField :: Typed.TypedTerm Errors.NoMatchingFieldError -> Typed.TypedTerm Errors.ResolutionError resolutionErrorNoMatchingField x = @@ -513,6 +563,10 @@ Core.fieldName = (Core.Name "other"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.errors.ResolutionError +resolutionErrorResolutionError :: Typed.TypedName Errors.ResolutionError +resolutionErrorResolutionError = Typed.TypedName (Core.Name "hydra.errors.ResolutionError") + -- | DSL injection for the unexpectedShape variant of hydra.errors.ResolutionError resolutionErrorUnexpectedShape :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm Errors.ResolutionError resolutionErrorUnexpectedShape x = @@ -574,6 +628,10 @@ Core.projectionFieldName = (Core.Name "expected")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.UnexpectedShapeError +unexpectedShapeErrorUnexpectedShapeError :: Typed.TypedName Errors.UnexpectedShapeError +unexpectedShapeErrorUnexpectedShapeError = Typed.TypedName (Core.Name "hydra.errors.UnexpectedShapeError") + -- | DSL updater for the actual field of hydra.errors.UnexpectedShapeError unexpectedShapeErrorWithActual :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm String -> Typed.TypedTerm Errors.UnexpectedShapeError unexpectedShapeErrorWithActual original newVal = @@ -651,6 +709,10 @@ Core.projectionFieldName = (Core.Name "rightType")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.errors.UnificationError +unificationErrorUnificationError :: Typed.TypedName Errors.UnificationError +unificationErrorUnificationError = Typed.TypedName (Core.Name "hydra.errors.UnificationError") + -- | DSL updater for the leftType field of hydra.errors.UnificationError unificationErrorWithLeftType :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Errors.UnificationError unificationErrorWithLeftType original newVal = @@ -753,6 +815,10 @@ Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"), Core.projectionFieldName = (Core.Name "path")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.errors.UnificationInferenceError +unificationInferenceErrorUnificationInferenceError :: Typed.TypedName Errors.UnificationInferenceError +unificationInferenceErrorUnificationInferenceError = Typed.TypedName (Core.Name "hydra.errors.UnificationInferenceError") -- | DSL updater for the cause field of hydra.errors.UnificationInferenceError unificationInferenceErrorWithCause :: Typed.TypedTerm Errors.UnificationInferenceError -> Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Errors.UnificationInferenceError diff --git a/src/main/haskell/Hydra/Dsl/Extract/Json.hs b/src/main/haskell/Hydra/Dsl/Extract/Json.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Extract/Json.hs @@ -0,0 +1,165 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.extract.json + +module Hydra.Dsl.Extract.Json where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Json.Writer as JsonWriter +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Json as Json +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Json.Writer as Writer +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | DSL reference to hydra.extract.json.expectArray +expectArray :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String [Model.Value]) +expectArray arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.expectArray")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.extract.json.expectNumber +expectNumber :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Sci.Scientific) +expectNumber arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.expectNumber")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.extract.json.expectObject +expectObject :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String (M.Map String Model.Value)) +expectObject arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.expectObject")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.extract.json.expectString +expectString :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String String) +expectString arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.expectString")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.extract.json.opt +opt :: Ord t0 => (Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map t0 t1) -> Typed.TypedTerm (Maybe t1)) +opt arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.opt")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.extract.json.optArray +optArray :: Ord t0 => (Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map t0 Model.Value) -> Typed.TypedTerm (Either String (Maybe [Model.Value]))) +optArray arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.optArray")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.extract.json.optString +optString :: Ord t0 => (Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map t0 Model.Value) -> Typed.TypedTerm (Either String (Maybe String))) +optString arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.optString")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.extract.json.require +require :: Typed.TypedTerm String -> Typed.TypedTerm (M.Map String t0) -> Typed.TypedTerm (Either String t0) +require arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.require")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.extract.json.requireArray +requireArray :: Typed.TypedTerm String -> Typed.TypedTerm (M.Map String Model.Value) -> Typed.TypedTerm (Either String [Model.Value]) +requireArray arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.requireArray")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.extract.json.requireNumber +requireNumber :: Typed.TypedTerm String -> Typed.TypedTerm (M.Map String Model.Value) -> Typed.TypedTerm (Either String Sci.Scientific) +requireNumber arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.requireNumber")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.extract.json.requireString +requireString :: Typed.TypedTerm String -> Typed.TypedTerm (M.Map String Model.Value) -> Typed.TypedTerm (Either String String) +requireString arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.requireString")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.extract.json.showValue +showValue :: Typed.TypedTerm Model.Value -> Typed.TypedTerm String +showValue arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.json.showValue")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/File.hs b/src/main/haskell/Hydra/Dsl/File.hs --- a/src/main/haskell/Hydra/Dsl/File.hs +++ b/src/main/haskell/Hydra/Dsl/File.hs @@ -5,8 +5,10 @@ module Hydra.Dsl.File where import qualified Hydra.Core as Core +import qualified Hydra.Decode.File as DecodeFile import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Time as DslTime +import qualified Hydra.Encode.File as EncodeFile import qualified Hydra.File as File import qualified Hydra.Time as Time import qualified Hydra.Typed as Typed @@ -21,6 +23,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.file.FileExtension"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.file.FileExtension +fileExtensionFileExtension :: Typed.TypedName File.FileExtension +fileExtensionFileExtension = Typed.TypedName (Core.Name "hydra.file.FileExtension") + -- | DSL constructor for the hydra.file.FilePath wrapper filePath :: Typed.TypedTerm String -> Typed.TypedTerm File.FilePath filePath x = @@ -28,6 +34,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.file.FilePath"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.file.FilePath +filePathFilePath :: Typed.TypedName File.FilePath +filePathFilePath = Typed.TypedName (Core.Name "hydra.file.FilePath") + -- | DSL constructor for hydra.file.FileStatus fileStatus :: Typed.TypedTerm File.FileType -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Time.Timespec -> Typed.TypedTerm (Maybe Time.Timespec) -> Typed.TypedTerm (Maybe Time.Timespec) -> Typed.TypedTerm File.FileStatus fileStatus fileType size modificationTime accessTime statusChangeTime = @@ -59,6 +69,10 @@ Core.projectionFieldName = (Core.Name "accessTime")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.file.FileStatus +fileStatusFileStatus :: Typed.TypedName File.FileStatus +fileStatusFileStatus = Typed.TypedName (Core.Name "hydra.file.FileStatus") + -- | DSL accessor for the fileType field of hydra.file.FileStatus fileStatusFileType :: Typed.TypedTerm File.FileStatus -> Typed.TypedTerm File.FileType fileStatusFileType x = @@ -320,6 +334,10 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "fifo"), Core.fieldTerm = Core.TermUnit}})) + +-- | DSL name token for hydra.file.FileType +fileTypeFileType :: Typed.TypedName File.FileType +fileTypeFileType = Typed.TypedName (Core.Name "hydra.file.FileType") -- | DSL injection for the link variant of hydra.file.FileType fileTypeLink :: Typed.TypedTerm File.FileType diff --git a/src/main/haskell/Hydra/Dsl/Formatting.hs b/src/main/haskell/Hydra/Dsl/Formatting.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Formatting.hs @@ -0,0 +1,205 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.formatting + +module Hydra.Dsl.Formatting where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Formatting as Formatting +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Set as S + +-- | DSL reference to hydra.formatting.capitalize +capitalize :: Typed.TypedTerm String -> Typed.TypedTerm String +capitalize arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.capitalize")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.convertCase +convertCase :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm String -> Typed.TypedTerm String +convertCase 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.formatting.convertCase")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.formatting.convertCaseCamelOrUnderscoreToLowerSnake +convertCaseCamelOrUnderscoreToLowerSnake :: Typed.TypedTerm String -> Typed.TypedTerm String +convertCaseCamelOrUnderscoreToLowerSnake arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCaseCamelOrUnderscoreToLowerSnake")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.convertCaseCamelToLowerSnake +convertCaseCamelToLowerSnake :: Typed.TypedTerm String -> Typed.TypedTerm String +convertCaseCamelToLowerSnake arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCaseCamelToLowerSnake")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.convertCaseCamelToUpperSnake +convertCaseCamelToUpperSnake :: Typed.TypedTerm String -> Typed.TypedTerm String +convertCaseCamelToUpperSnake arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCaseCamelToUpperSnake")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.convertCasePascalToUpperSnake +convertCasePascalToUpperSnake :: Typed.TypedTerm String -> Typed.TypedTerm String +convertCasePascalToUpperSnake arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCasePascalToUpperSnake")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.decapitalize +decapitalize :: Typed.TypedTerm String -> Typed.TypedTerm String +decapitalize arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.decapitalize")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.escapeWithUnderscore +escapeWithUnderscore :: Typed.TypedTerm (S.Set String) -> Typed.TypedTerm String -> Typed.TypedTerm String +escapeWithUnderscore arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.escapeWithUnderscore")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.formatting.indentLines +indentLines :: Typed.TypedTerm String -> Typed.TypedTerm String +indentLines arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.indentLines")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.javaStyleComment +javaStyleComment :: Typed.TypedTerm String -> Typed.TypedTerm String +javaStyleComment arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.javaStyleComment")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.mapFirstLetter +mapFirstLetter :: Typed.TypedTerm (String -> String) -> Typed.TypedTerm String -> Typed.TypedTerm String +mapFirstLetter arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.mapFirstLetter")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.formatting.nonAlnumToUnderscores +nonAlnumToUnderscores :: Typed.TypedTerm String -> Typed.TypedTerm String +nonAlnumToUnderscores arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.nonAlnumToUnderscores")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.normalizeComment +normalizeComment :: Typed.TypedTerm String -> Typed.TypedTerm String +normalizeComment arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.normalizeComment")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.sanitizeWithUnderscores +sanitizeWithUnderscores :: Typed.TypedTerm (S.Set String) -> Typed.TypedTerm String -> Typed.TypedTerm String +sanitizeWithUnderscores arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.sanitizeWithUnderscores")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.formatting.showList +showList :: Typed.TypedTerm (t0 -> String) -> Typed.TypedTerm [t0] -> Typed.TypedTerm String +showList arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.showList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.formatting.stripLeadingAndTrailingWhitespace +stripLeadingAndTrailingWhitespace :: Typed.TypedTerm String -> Typed.TypedTerm String +stripLeadingAndTrailingWhitespace arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.stripLeadingAndTrailingWhitespace")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.withCharacterAliases +withCharacterAliases :: Typed.TypedTerm String -> Typed.TypedTerm String +withCharacterAliases arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.withCharacterAliases")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.formatting.wrapLine +wrapLine :: Typed.TypedTerm Int -> Typed.TypedTerm String -> Typed.TypedTerm String +wrapLine arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.wrapLine")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) diff --git a/src/main/haskell/Hydra/Dsl/Graph.hs b/src/main/haskell/Hydra/Dsl/Graph.hs --- a/src/main/haskell/Hydra/Dsl/Graph.hs +++ b/src/main/haskell/Hydra/Dsl/Graph.hs @@ -19,6 +19,20 @@ import qualified Data.Map as M import qualified Data.Set as S +-- | DSL composition builder for the decoder of hydra.graph.TermCoder +decodeTermCoder :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Graph.TermCoder a)) +decodeTermCoder a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.graph.termCoder")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the encoder of hydra.graph.TermCoder +encodeTermCoder :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Graph.TermCoder a -> Core.Term) +encodeTermCoder a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.graph.termCoder")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + -- | DSL constructor for hydra.graph.Graph graph :: Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm (M.Map Core.Name Core.TypeVariableConstraints) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Graph.Primitive) -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Graph.Graph graph boundTerms boundTypes classConstraints lambdaVariables metadata primitives schemaTypes typeVariables = @@ -77,6 +91,10 @@ Core.projectionFieldName = (Core.Name "classConstraints")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.graph.Graph +graphGraph :: Typed.TypedName Graph.Graph +graphGraph = Typed.TypedName (Core.Name "hydra.graph.Graph") + -- | DSL accessor for the lambdaVariables field of hydra.graph.Graph graphLambdaVariables :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (S.Set Core.Name) graphLambdaVariables x = @@ -610,6 +628,10 @@ Core.fieldName = (Core.Name "primitives"), Core.fieldTerm = (Typed.unTypedTerm primitives)}]})) +-- | DSL name token for hydra.graph.Library +libraryLibrary :: Typed.TypedName Graph.Library +libraryLibrary = Typed.TypedName (Core.Name "hydra.graph.Library") + -- | DSL accessor for the name field of hydra.graph.Library libraryName :: Typed.TypedTerm Graph.Library -> Typed.TypedTerm Packaging.ModuleName libraryName x = @@ -740,6 +762,10 @@ Core.projectionFieldName = (Core.Name "implementation")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.graph.Primitive +primitivePrimitive :: Typed.TypedName Graph.Primitive +primitivePrimitive = Typed.TypedName (Core.Name "hydra.graph.Primitive") + -- | DSL updater for the definition field of hydra.graph.Primitive primitiveWithDefinition :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Graph.Primitive primitiveWithDefinition original newVal = @@ -807,6 +833,10 @@ Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), Core.projectionFieldName = (Core.Name "encode")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.graph.TermCoder +termCoderTermCoder :: Typed.TypedName (Graph.TermCoder a) +termCoderTermCoder = Typed.TypedName (Core.Name "hydra.graph.TermCoder") -- | DSL accessor for the type field of hydra.graph.TermCoder termCoderType :: Typed.TypedTerm (Graph.TermCoder a) -> Typed.TypedTerm Core.Type diff --git a/src/main/haskell/Hydra/Dsl/Json/Bootstrap.hs b/src/main/haskell/Hydra/Dsl/Json/Bootstrap.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Bootstrap.hs @@ -0,0 +1,37 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.json.bootstrap + +module Hydra.Dsl.Json.Bootstrap where + +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +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.Errors as DslErrors +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Packaging as DslPackaging +import qualified Hydra.Dsl.Paths as DslPaths +import qualified Hydra.Dsl.Typing as DslTyping +import qualified Hydra.Dsl.Util as DslUtil +import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Error.Checking as Checking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Errors as Errors +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Bootstrap as Bootstrap +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Paths as Paths +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +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.json.bootstrap.typesByName +typesByName :: Typed.TypedTerm (M.Map Core.Name Core.Type) +typesByName = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.bootstrap.typesByName")) diff --git a/src/main/haskell/Hydra/Dsl/Json/Decode.hs b/src/main/haskell/Hydra/Dsl/Json/Decode.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Decode.hs @@ -0,0 +1,153 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.json.decode + +module Hydra.Dsl.Json.Decode where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Decode as Decode +import qualified Hydra.Json.Model as Model +import qualified Hydra.Literals as Literals +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Show.Core as ShowCore +import qualified Hydra.Strip as Strip +import qualified Hydra.Substitution as Substitution +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | DSL reference to hydra.json.decode.decodeFloat +decodeFloat :: Typed.TypedTerm Core.FloatType -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Core.Term) +decodeFloat arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.decodeFloat")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.json.decode.decodeInteger +decodeInteger :: Typed.TypedTerm Core.IntegerType -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Core.Term) +decodeInteger arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.decodeInteger")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.json.decode.decodeLiteral +decodeLiteral :: Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Core.Term) +decodeLiteral arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.decodeLiteral")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.json.decode.expectArray +expectArray :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String [Model.Value]) +expectArray arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.expectArray")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.decode.expectNumber +expectNumber :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Sci.Scientific) +expectNumber arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.expectNumber")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.decode.expectObject +expectObject :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String (M.Map String Model.Value)) +expectObject arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.expectObject")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.decode.expectString +expectString :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String String) +expectString arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.expectString")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.decode.fromJson +fromJson :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Core.Term) +fromJson 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.json.decode.fromJson")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.json.decode.parseSpecialFloat +parseSpecialFloat :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Double) +parseSpecialFloat arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.parseSpecialFloat")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.decode.parseSpecialFloat32 +parseSpecialFloat32 :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe Float) +parseSpecialFloat32 arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decode.parseSpecialFloat32")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Json/Decoding.hs b/src/main/haskell/Hydra/Dsl/Json/Decoding.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Decoding.hs @@ -0,0 +1,117 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.json.decoding + +module Hydra.Dsl.Json.Decoding where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Decoding as Decoding +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.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | DSL reference to hydra.json.decoding.decodeArray +decodeArray :: Typed.TypedTerm (Model.Value -> Either String t0) -> Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String [t0]) +decodeArray arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decoding.decodeArray")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.json.decoding.decodeBoolean +decodeBoolean :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String Bool) +decodeBoolean arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decoding.decodeBoolean")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.decoding.decodeField +decodeField :: Typed.TypedTerm (t0 -> Either String t1) -> Typed.TypedTerm String -> Typed.TypedTerm (M.Map String t0) -> Typed.TypedTerm (Either String t1) +decodeField 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.json.decoding.decodeField")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.json.decoding.decodeObject +decodeObject :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String (M.Map String Model.Value)) +decodeObject arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decoding.decodeObject")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.decoding.decodeOptionalField +decodeOptionalField :: Ord t3 => (Typed.TypedTerm (t0 -> Either t1 t2) -> Typed.TypedTerm t3 -> Typed.TypedTerm (M.Map t3 t0) -> Typed.TypedTerm (Either t1 (Maybe t2))) +decodeOptionalField 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.json.decoding.decodeOptionalField")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.json.decoding.decodeString +decodeString :: Typed.TypedTerm Model.Value -> Typed.TypedTerm (Either String String) +decodeString arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.decoding.decodeString")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Json/Encode.hs b/src/main/haskell/Hydra/Dsl/Json/Encode.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Encode.hs @@ -0,0 +1,119 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.json.encode + +module Hydra.Dsl.Json.Encode where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Encode as Encode +import qualified Hydra.Json.Model as Model +import qualified Hydra.Literals as Literals +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Show.Core as ShowCore +import qualified Hydra.Strip as Strip +import qualified Hydra.Substitution as Substitution +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | DSL reference to hydra.json.encode.encodeFloat +encodeFloat :: Typed.TypedTerm Core.FloatValue -> Typed.TypedTerm (Either t0 Model.Value) +encodeFloat arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.encodeFloat")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.encode.encodeInteger +encodeInteger :: Typed.TypedTerm Core.IntegerValue -> Typed.TypedTerm (Either t0 Model.Value) +encodeInteger arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.encodeInteger")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.encode.encodeLiteral +encodeLiteral :: Typed.TypedTerm Core.Literal -> Typed.TypedTerm (Either t0 Model.Value) +encodeLiteral arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.encodeLiteral")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.encode.requiresJsonStringSentinel +requiresJsonStringSentinel :: Typed.TypedTerm String -> Typed.TypedTerm Bool +requiresJsonStringSentinel arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.requiresJsonStringSentinel")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.encode.toJson +toJson :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either String Model.Value) +toJson 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.json.encode.toJson")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.json.encode.toJsonUntyped +toJsonUntyped :: Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either String Model.Value) +toJsonUntyped arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.encode.toJsonUntyped")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Json/Model.hs b/src/main/haskell/Hydra/Dsl/Json/Model.hs --- a/src/main/haskell/Hydra/Dsl/Json/Model.hs +++ b/src/main/haskell/Hydra/Dsl/Json/Model.hs @@ -5,7 +5,9 @@ module Hydra.Dsl.Json.Model where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Json.Model as DecodeJsonModel import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Json.Model as EncodeJsonModel import qualified Hydra.Json.Model as Model import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) @@ -64,3 +66,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "string"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.json.model.Value +valueValue :: Typed.TypedName Model.Value +valueValue = Typed.TypedName (Core.Name "hydra.json.model.Value") diff --git a/src/main/haskell/Hydra/Dsl/Json/Parser.hs b/src/main/haskell/Hydra/Dsl/Json/Parser.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Parser.hs @@ -0,0 +1,143 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.json.parser + +module Hydra.Dsl.Json.Parser where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Json.Parser as Parser +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsers as Parsers +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.json.parser.digit +digit :: Typed.TypedTerm (Parsing.Parser Int) +digit = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.digit")) + +-- | DSL reference to hydra.json.parser.digits +digits :: Typed.TypedTerm (Parsing.Parser String) +digits = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.digits")) + +-- | DSL reference to hydra.json.parser.jsonArray +jsonArray :: Typed.TypedTerm (Parsing.Parser Model.Value) +jsonArray = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonArray")) + +-- | DSL reference to hydra.json.parser.jsonBool +jsonBool :: Typed.TypedTerm (Parsing.Parser Model.Value) +jsonBool = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonBool")) + +-- | DSL reference to hydra.json.parser.jsonEscapeChar +jsonEscapeChar :: Typed.TypedTerm (Parsing.Parser Int) +jsonEscapeChar = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonEscapeChar")) + +-- | DSL reference to hydra.json.parser.jsonExponentPart +jsonExponentPart :: Typed.TypedTerm (Parsing.Parser (Maybe String)) +jsonExponentPart = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonExponentPart")) + +-- | DSL reference to hydra.json.parser.jsonFractionPart +jsonFractionPart :: Typed.TypedTerm (Parsing.Parser (Maybe String)) +jsonFractionPart = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonFractionPart")) + +-- | DSL reference to hydra.json.parser.jsonIntegerPart +jsonIntegerPart :: Typed.TypedTerm (Parsing.Parser String) +jsonIntegerPart = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonIntegerPart")) + +-- | DSL reference to hydra.json.parser.jsonKeyValue +jsonKeyValue :: Typed.TypedTerm (Parsing.Parser (String, Model.Value)) +jsonKeyValue = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonKeyValue")) + +-- | DSL reference to hydra.json.parser.jsonNull +jsonNull :: Typed.TypedTerm (Parsing.Parser Model.Value) +jsonNull = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonNull")) + +-- | DSL reference to hydra.json.parser.jsonNumber +jsonNumber :: Typed.TypedTerm (Parsing.Parser Model.Value) +jsonNumber = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonNumber")) + +-- | DSL reference to hydra.json.parser.jsonObject +jsonObject :: Typed.TypedTerm (Parsing.Parser Model.Value) +jsonObject = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonObject")) + +-- | DSL reference to hydra.json.parser.jsonString +jsonString :: Typed.TypedTerm (Parsing.Parser Model.Value) +jsonString = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonString")) + +-- | DSL reference to hydra.json.parser.jsonStringChar +jsonStringChar :: Typed.TypedTerm (Parsing.Parser Int) +jsonStringChar = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonStringChar")) + +-- | DSL reference to hydra.json.parser.jsonValue +jsonValue :: Typed.TypedTerm (Parsing.Parser Model.Value) +jsonValue = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.jsonValue")) + +-- | DSL reference to hydra.json.parser.parseJson +parseJson :: Typed.TypedTerm String -> Typed.TypedTerm (Parsing.ParseResult Model.Value) +parseJson arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.parser.parseJson")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.parser.token +token :: Typed.TypedTerm (Parsing.Parser t0) -> Typed.TypedTerm (Parsing.Parser t0) +token arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.parser.token")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.parser.whitespace +whitespace :: Typed.TypedTerm (Parsing.Parser ()) +whitespace = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.parser.whitespace")) diff --git a/src/main/haskell/Hydra/Dsl/Json/Writer.hs b/src/main/haskell/Hydra/Dsl/Json/Writer.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Writer.hs @@ -0,0 +1,105 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.json.writer + +module Hydra.Dsl.Json.Writer where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Serialization as DslSerialization +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Json.Writer as Writer +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Serialization as Serialization +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.json.writer.colonOp +colonOp :: Typed.TypedTerm Ast.Op +colonOp = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.json.writer.colonOp")) + +-- | DSL reference to hydra.json.writer.hexByte +hexByte :: Typed.TypedTerm Int -> Typed.TypedTerm String +hexByte arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.hexByte")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.writer.jsonString +jsonString :: Typed.TypedTerm String -> Typed.TypedTerm String +jsonString arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.jsonString")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.writer.keyValueToExpr +keyValueToExpr :: Typed.TypedTerm (String, Model.Value) -> Typed.TypedTerm Ast.Expr +keyValueToExpr arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.keyValueToExpr")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.writer.printJson +printJson :: Typed.TypedTerm Model.Value -> Typed.TypedTerm String +printJson arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.printJson")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.writer.valueToExpr +valueToExpr :: Typed.TypedTerm Model.Value -> Typed.TypedTerm Ast.Expr +valueToExpr arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.writer.valueToExpr")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Json/Yaml/Decode.hs b/src/main/haskell/Hydra/Dsl/Json/Yaml/Decode.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Yaml/Decode.hs @@ -0,0 +1,89 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.json.yaml.decode + +module Hydra.Dsl.Json.Yaml.Decode where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Decode as JsonDecode +import qualified Hydra.Dsl.Json.Model as DslJsonModel +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Dsl.Yaml.Model as DslYamlModel +import qualified Hydra.Error.Checking as Checking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Decode as Decode +import qualified Hydra.Json.Model as JsonModel +import qualified Hydra.Json.Yaml.Decode as YamlDecode +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import qualified Hydra.Yaml.Model as YamlModel +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.json.yaml.decode.fromYaml +fromYaml :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm YamlModel.Node -> Typed.TypedTerm (Either String Core.Term) +fromYaml 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.json.yaml.decode.fromYaml")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.json.yaml.decode.yamlToJson +yamlToJson :: Typed.TypedTerm YamlModel.Node -> Typed.TypedTerm (Either String JsonModel.Value) +yamlToJson arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.yaml.decode.yamlToJson")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Json/Yaml/Encode.hs b/src/main/haskell/Hydra/Dsl/Json/Yaml/Encode.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Yaml/Encode.hs @@ -0,0 +1,89 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.json.yaml.encode + +module Hydra.Dsl.Json.Yaml.Encode where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Encode as JsonEncode +import qualified Hydra.Dsl.Json.Model as DslJsonModel +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Dsl.Yaml.Model as DslYamlModel +import qualified Hydra.Error.Checking as Checking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Encode as Encode +import qualified Hydra.Json.Model as JsonModel +import qualified Hydra.Json.Yaml.Encode as YamlEncode +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import qualified Hydra.Yaml.Model as YamlModel +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.json.yaml.encode.jsonToYaml +jsonToYaml :: Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm YamlModel.Node +jsonToYaml arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.json.yaml.encode.jsonToYaml")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.json.yaml.encode.toYaml +toYaml :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either String YamlModel.Node) +toYaml 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.json.yaml.encode.toYaml")), + 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/Lexical.hs b/src/main/haskell/Hydra/Dsl/Lexical.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Lexical.hs @@ -0,0 +1,299 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.lexical + +module Hydra.Dsl.Lexical where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Scoping as DslScoping +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Scoping as Scoping +import qualified Hydra.Show.Core as ShowCore +import qualified Hydra.Show.Errors as ShowErrors +import qualified Hydra.Strip as Strip +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL reference to hydra.lexical.buildGraph +buildGraph :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (M.Map Core.Name (Maybe Core.Term)) -> Typed.TypedTerm (M.Map Core.Name Graph.Primitive) -> Typed.TypedTerm Graph.Graph +buildGraph 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.lexical.buildGraph")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.lexical.chooseUniqueName +chooseUniqueName :: Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name +chooseUniqueName arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.chooseUniqueName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.dereferenceSchemaType +dereferenceSchemaType :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm (Maybe Core.TypeScheme) +dereferenceSchemaType arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.dereferenceSchemaType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.dereferenceVariable +dereferenceVariable :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.Binding) +dereferenceVariable arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.dereferenceVariable")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.elementsToGraph +elementsToGraph :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Graph.Graph +elementsToGraph 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.lexical.elementsToGraph")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.lexical.emptyGraph +emptyGraph :: Typed.TypedTerm Graph.Graph +emptyGraph = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.lexical.emptyGraph")) + +-- | DSL reference to hydra.lexical.emptyInferenceContext +emptyInferenceContext :: Typed.TypedTerm Typing.InferenceContext +emptyInferenceContext = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.lexical.emptyInferenceContext")) + +-- | DSL reference to hydra.lexical.fieldsOf +fieldsOf :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Core.FieldType] +fieldsOf arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.fieldsOf")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.lexical.getField +getField :: Typed.TypedTerm (M.Map Core.Name t0) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (t0 -> Either Errors.Error t1) -> Typed.TypedTerm (Either Errors.Error t1) +getField 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.lexical.getField")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.lexical.graphToBindings +graphToBindings :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm [Core.Binding] +graphToBindings arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.graphToBindings")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.lexical.graphWithPrimitives +graphWithPrimitives :: Typed.TypedTerm [Graph.Primitive] -> Typed.TypedTerm [Graph.Primitive] -> Typed.TypedTerm Graph.Graph +graphWithPrimitives arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.graphWithPrimitives")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.lookupBinding +lookupBinding :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Binding) +lookupBinding arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.lookupBinding")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.lookupPrimitive +lookupPrimitive :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Graph.Primitive) +lookupPrimitive arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.lookupPrimitive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.lookupTerm +lookupTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term) +lookupTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.lookupTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.matchEnum +matchEnum :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm [(Core.Name, t0)] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error t0) +matchEnum 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.lexical.matchEnum")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.lexical.matchRecord +matchRecord :: Typed.TypedTerm t0 -> Typed.TypedTerm (M.Map Core.Name Core.Term -> Either Errors.Error t1) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error t1) +matchRecord 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.lexical.matchRecord")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.lexical.matchUnion +matchUnion :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm [(Core.Name, (Core.Term -> Either Errors.Error t0))] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error t0) +matchUnion 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.lexical.matchUnion")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.lexical.matchUnitField +matchUnitField :: Typed.TypedTerm t0 -> Typed.TypedTerm t1 -> Typed.TypedTerm (t0, (t2 -> Either t3 t1)) +matchUnitField arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.matchUnitField")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.requireBinding +requireBinding :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.Binding) +requireBinding arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.requireBinding")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.requirePrimitive +requirePrimitive :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Graph.Primitive) +requirePrimitive arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.requirePrimitive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.requirePrimitiveType +requirePrimitiveType :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.TypeScheme) +requirePrimitiveType arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.requirePrimitiveType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.requireTerm +requireTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.Term) +requireTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.requireTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.resolveTerm +resolveTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term) +resolveTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.resolveTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.stripAndDereferenceTerm +stripAndDereferenceTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error Core.Term) +stripAndDereferenceTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.lexical.stripAndDereferenceTermEither +stripAndDereferenceTermEither :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error Core.Term) +stripAndDereferenceTermEither arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) diff --git a/src/main/haskell/Hydra/Dsl/Lib/Defaults.hs b/src/main/haskell/Hydra/Dsl/Lib/Defaults.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Lib/Defaults.hs @@ -0,0 +1,26 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.lib.defaults + +module Hydra.Dsl.Lib.Defaults where + +import qualified Hydra.Core as Core +import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Dsl.Lib.Eithers as Eithers +import qualified Hydra.Dsl.Lib.Equality as Equality +import qualified Hydra.Dsl.Lib.Lists as Lists +import qualified Hydra.Dsl.Lib.Logic as Logic +import qualified Hydra.Dsl.Lib.Maps as Maps +import qualified Hydra.Dsl.Lib.Math as Math +import qualified Hydra.Dsl.Lib.Optionals as Optionals +import qualified Hydra.Dsl.Lib.Pairs as Pairs +import qualified Hydra.Dsl.Lib.Sets as Sets +import qualified Hydra.Lib.Defaults as Defaults +import qualified Hydra.Typed as Typed +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | DSL reference to hydra.lib.defaults.defaultImplementations +defaultImplementations :: Typed.TypedTerm (M.Map Core.Name Core.Term) +defaultImplementations = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.lib.defaults.defaultImplementations")) diff --git a/src/main/haskell/Hydra/Dsl/Names.hs b/src/main/haskell/Hydra/Dsl/Names.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Names.hs @@ -0,0 +1,229 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.names + +module Hydra.Dsl.Names where + +import qualified Hydra.Annotations as Annotations +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Constants as Constants +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +import qualified Hydra.Dsl.Annotations as DslAnnotations +import qualified Hydra.Dsl.Ast as DslAst +import qualified Hydra.Dsl.Coders as DslCoders +import qualified Hydra.Dsl.Constants as DslConstants +import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Dsl.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Packaging as DslPackaging +import qualified Hydra.Dsl.Parsing as DslParsing +import qualified Hydra.Dsl.Paths as DslPaths +import qualified Hydra.Dsl.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Formatting as Formatting +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Names as Names +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL reference to hydra.names.chooseUniqueLabel +chooseUniqueLabel :: Typed.TypedTerm (S.Set String) -> Typed.TypedTerm String -> Typed.TypedTerm String +chooseUniqueLabel arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.chooseUniqueLabel")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.names.compactName +compactName :: Typed.TypedTerm (M.Map Packaging.ModuleName String) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm String +compactName arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.compactName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.names.derivedBindingName +derivedBindingName :: Typed.TypedTerm [String] -> Typed.TypedTerm Bool -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name +derivedBindingName 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.names.derivedBindingName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.names.derivedDefinitionName +derivedDefinitionName :: Typed.TypedTerm [String] -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Core.Name -> Typed.TypedTerm String -> Typed.TypedTerm Core.Name +derivedDefinitionName arg0 arg1 arg2 arg3 arg4 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.derivedDefinitionName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})) + +-- | DSL reference to hydra.names.derivedModuleName +derivedModuleName :: Typed.TypedTerm [String] -> Typed.TypedTerm Bool -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.ModuleName +derivedModuleName 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.names.derivedModuleName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.names.freshName +freshName :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (Core.Name, Typing.InferenceContext) +freshName arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.freshName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.names.freshNames +freshNames :: Typed.TypedTerm Int -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm ([Core.Name], Typing.InferenceContext) +freshNames arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.freshNames")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.names.localNameOf +localNameOf :: Typed.TypedTerm Core.Name -> Typed.TypedTerm String +localNameOf arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.localNameOf")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.names.moduleNameOf +moduleNameOf :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Packaging.ModuleName) +moduleNameOf arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.moduleNameOf")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.names.moduleNameToFilePath +moduleNameToFilePath :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm File.FileExtension -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm String +moduleNameToFilePath 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.names.moduleNameToFilePath")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.names.nameToFilePath +nameToFilePath :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm File.FileExtension -> Typed.TypedTerm Core.Name -> Typed.TypedTerm String +nameToFilePath 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.names.nameToFilePath")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.names.normalTypeVariable +normalTypeVariable :: Typed.TypedTerm Int -> Typed.TypedTerm Core.Name +normalTypeVariable arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.normalTypeVariable")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.names.pushSubtermStep +pushSubtermStep :: Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Typing.InferenceContext +pushSubtermStep arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.pushSubtermStep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.names.qname +qname :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm String -> Typed.TypedTerm Core.Name +qname arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.qname")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.names.qualifyName +qualifyName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Util.QualifiedName +qualifyName arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.qualifyName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.names.restoreTrace +restoreTrace :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Typing.InferenceContext +restoreTrace arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.restoreTrace")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.names.unqualifyName +unqualifyName :: Typed.TypedTerm Util.QualifiedName -> Typed.TypedTerm Core.Name +unqualifyName arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.names.unqualifyName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Packaging.hs b/src/main/haskell/Hydra/Dsl/Packaging.hs --- a/src/main/haskell/Hydra/Dsl/Packaging.hs +++ b/src/main/haskell/Hydra/Dsl/Packaging.hs @@ -5,14 +5,20 @@ module Hydra.Dsl.Packaging where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Packaging as DecodePackaging import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Typing as DslTyping +import qualified Hydra.Encode.Packaging as EncodePackaging import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL name token for hydra.packaging.Definition +definitionDefinition :: Typed.TypedName Packaging.Definition +definitionDefinition = Typed.TypedName (Core.Name "hydra.packaging.Definition") + -- | DSL injection for the primitive variant of hydra.packaging.Definition definitionPrimitive :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Packaging.Definition definitionPrimitive x = @@ -22,6 +28,10 @@ Core.fieldName = (Core.Name "primitive"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.packaging.DefinitionReference +definitionReferenceDefinitionReference :: Typed.TypedName Packaging.DefinitionReference +definitionReferenceDefinitionReference = Typed.TypedName (Core.Name "hydra.packaging.DefinitionReference") + -- | DSL injection for the primitive variant of hydra.packaging.DefinitionReference definitionReferencePrimitive :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.DefinitionReference definitionReferencePrimitive x = @@ -76,6 +86,10 @@ Core.fieldName = (Core.Name "api"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.packaging.DependencyScope +dependencyScopeDependencyScope :: Typed.TypedName Packaging.DependencyScope +dependencyScopeDependencyScope = Typed.TypedName (Core.Name "hydra.packaging.DependencyScope") + -- | DSL injection for the runtime variant of hydra.packaging.DependencyScope dependencyScopeRuntime :: Typed.TypedTerm Packaging.DependencyScope dependencyScopeRuntime = @@ -140,6 +154,10 @@ Core.projectionFieldName = (Core.Name "description")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.EntityMetadata +entityMetadataEntityMetadata :: Typed.TypedName Packaging.EntityMetadata +entityMetadataEntityMetadata = Typed.TypedName (Core.Name "hydra.packaging.EntityMetadata") + -- | DSL accessor for the lifecycle field of hydra.packaging.EntityMetadata entityMetadataLifecycle :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm (Maybe Packaging.LifecycleInfo) entityMetadataLifecycle x = @@ -291,6 +309,10 @@ Core.fieldName = (Core.Name "definition"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.packaging.EntityReference +entityReferenceEntityReference :: Typed.TypedName Packaging.EntityReference +entityReferenceEntityReference = Typed.TypedName (Core.Name "hydra.packaging.EntityReference") + -- | DSL injection for the module variant of hydra.packaging.EntityReference entityReferenceModule :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.EntityReference entityReferenceModule x = @@ -358,6 +380,10 @@ Core.projectionFieldName = (Core.Name "deprecatedSince")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.LifecycleInfo +lifecycleInfoLifecycleInfo :: Typed.TypedName Packaging.LifecycleInfo +lifecycleInfoLifecycleInfo = Typed.TypedName (Core.Name "hydra.packaging.LifecycleInfo") + -- | DSL updater for the availableSince field of hydra.packaging.LifecycleInfo lifecycleInfoWithAvailableSince :: Typed.TypedTerm Packaging.LifecycleInfo -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Packaging.LifecycleInfo lifecycleInfoWithAvailableSince original newVal = @@ -451,6 +477,10 @@ Core.projectionFieldName = (Core.Name "module")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.ModuleDependency +moduleDependencyModuleDependency :: Typed.TypedName Packaging.ModuleDependency +moduleDependencyModuleDependency = Typed.TypedName (Core.Name "hydra.packaging.ModuleDependency") + -- | DSL accessor for the package field of hydra.packaging.ModuleDependency moduleDependencyPackage :: Typed.TypedTerm Packaging.ModuleDependency -> Typed.TypedTerm (Maybe Packaging.PackageName) moduleDependencyPackage x = @@ -503,6 +533,10 @@ Core.projectionFieldName = (Core.Name "metadata")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.Module +moduleModule :: Typed.TypedName Packaging.Module +moduleModule = Typed.TypedName (Core.Name "hydra.packaging.Module") + -- | DSL accessor for the name field of hydra.packaging.Module moduleName :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Packaging.ModuleName moduleName x = @@ -519,6 +553,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.packaging.ModuleName"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.ModuleName +moduleNameModuleName :: Typed.TypedName Packaging.ModuleName +moduleNameModuleName = Typed.TypedName (Core.Name "hydra.packaging.ModuleName") + -- | DSL updater for the definitions field of hydra.packaging.Module moduleWithDefinitions :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm Packaging.Module moduleWithDefinitions original newVal = @@ -696,6 +734,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.PackageDependency +packageDependencyPackageDependency :: Typed.TypedName Packaging.PackageDependency +packageDependencyPackageDependency = Typed.TypedName (Core.Name "hydra.packaging.PackageDependency") + -- | DSL accessor for the scope field of hydra.packaging.PackageDependency packageDependencyScope :: Typed.TypedTerm Packaging.PackageDependency -> Typed.TypedTerm (Maybe Packaging.DependencyScope) packageDependencyScope x = @@ -820,6 +862,14 @@ Core.wrappedTermTypeName = (Core.Name "hydra.packaging.PackageName"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.PackageName +packageNamePackageName :: Typed.TypedName Packaging.PackageName +packageNamePackageName = Typed.TypedName (Core.Name "hydra.packaging.PackageName") + +-- | DSL name token for hydra.packaging.Package +packagePackage :: Typed.TypedName Packaging.Package +packagePackage = Typed.TypedName (Core.Name "hydra.packaging.Package") + -- | DSL updater for the dependencies field of hydra.packaging.Package packageWithDependencies :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm [Packaging.PackageDependency] -> Typed.TypedTerm Packaging.Package packageWithDependencies original newVal = @@ -1014,6 +1064,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.PrimitiveDefinition +primitiveDefinitionPrimitiveDefinition :: Typed.TypedName Packaging.PrimitiveDefinition +primitiveDefinitionPrimitiveDefinition = Typed.TypedName (Core.Name "hydra.packaging.PrimitiveDefinition") + -- | DSL accessor for the signature field of hydra.packaging.PrimitiveDefinition primitiveDefinitionSignature :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Typing.TermSignature primitiveDefinitionSignature x = @@ -1348,6 +1402,10 @@ Core.projectionFieldName = (Core.Name "signature")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.TermDefinition +termDefinitionTermDefinition :: Typed.TypedName Packaging.TermDefinition +termDefinitionTermDefinition = Typed.TypedName (Core.Name "hydra.packaging.TermDefinition") + -- | DSL updater for the body field of hydra.packaging.TermDefinition termDefinitionWithBody :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Packaging.TermDefinition termDefinitionWithBody original newVal = @@ -1515,6 +1573,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.TypeDefinition +typeDefinitionTypeDefinition :: Typed.TypedName Packaging.TypeDefinition +typeDefinitionTypeDefinition = Typed.TypedName (Core.Name "hydra.packaging.TypeDefinition") + -- | DSL updater for the body field of hydra.packaging.TypeDefinition typeDefinitionWithBody :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Packaging.TypeDefinition typeDefinitionWithBody original newVal = @@ -1646,6 +1708,10 @@ Core.projectionFieldName = (Core.Name "upperExclusive")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.packaging.VersionRange +versionRangeVersionRange :: Typed.TypedName Packaging.VersionRange +versionRangeVersionRange = Typed.TypedName (Core.Name "hydra.packaging.VersionRange") + -- | DSL updater for the lowerInclusive field of hydra.packaging.VersionRange versionRangeWithLowerInclusive :: Typed.TypedTerm Packaging.VersionRange -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Packaging.VersionRange versionRangeWithLowerInclusive original newVal = @@ -1715,3 +1781,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "range"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + +-- | DSL name token for hydra.packaging.VersionSpecifier +versionSpecifierVersionSpecifier :: Typed.TypedName Packaging.VersionSpecifier +versionSpecifierVersionSpecifier = Typed.TypedName (Core.Name "hydra.packaging.VersionSpecifier") + +-- | DSL name token for hydra.packaging.Version +versionVersion :: Typed.TypedName Packaging.Version +versionVersion = Typed.TypedName (Core.Name "hydra.packaging.Version") diff --git a/src/main/haskell/Hydra/Dsl/Parsing.hs b/src/main/haskell/Hydra/Dsl/Parsing.hs --- a/src/main/haskell/Hydra/Dsl/Parsing.hs +++ b/src/main/haskell/Hydra/Dsl/Parsing.hs @@ -5,12 +5,58 @@ module Hydra.Dsl.Parsing where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Parsing as DecodeParsing import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Parsing as EncodeParsing +import qualified Hydra.Errors as Errors +import qualified Hydra.Graph as Graph import qualified Hydra.Parsing as Parsing import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL composition builder for the decoder of hydra.parsing.ParseResult +decodeParseResult :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseResult a)) +decodeParseResult a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parseResult")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the decoder of hydra.parsing.ParseSuccess +decodeParseSuccess :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseSuccess a)) +decodeParseSuccess a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parseSuccess")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the decoder of hydra.parsing.Parser +decodeParser :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.Parser a)) +decodeParser a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parser")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the encoder of hydra.parsing.ParseResult +encodeParseResult :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Parsing.ParseResult a -> Core.Term) +encodeParseResult a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parseResult")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the encoder of hydra.parsing.ParseSuccess +encodeParseSuccess :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Parsing.ParseSuccess a -> Core.Term) +encodeParseSuccess a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parseSuccess")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the encoder of hydra.parsing.Parser +encodeParser :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Parsing.Parser a -> Core.Term) +encodeParser a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parser")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + -- | DSL constructor for hydra.parsing.ParseError parseError :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Parsing.ParseError parseError message remainder = @@ -33,6 +79,10 @@ Core.projectionFieldName = (Core.Name "message")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.parsing.ParseError +parseErrorParseError :: Typed.TypedName Parsing.ParseError +parseErrorParseError = Typed.TypedName (Core.Name "hydra.parsing.ParseError") + -- | DSL accessor for the remainder field of hydra.parsing.ParseError parseErrorRemainder :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm String parseErrorRemainder x = @@ -85,6 +135,10 @@ Core.fieldName = (Core.Name "failure"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.parsing.ParseResult +parseResultParseResult :: Typed.TypedName (Parsing.ParseResult a) +parseResultParseResult = Typed.TypedName (Core.Name "hydra.parsing.ParseResult") + -- | DSL injection for the success variant of hydra.parsing.ParseResult parseResultSuccess :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm (Parsing.ParseResult a) parseResultSuccess x = @@ -107,6 +161,10 @@ Core.fieldName = (Core.Name "remainder"), Core.fieldTerm = (Typed.unTypedTerm remainder)}]})) +-- | DSL name token for hydra.parsing.ParseSuccess +parseSuccessParseSuccess :: Typed.TypedName (Parsing.ParseSuccess a) +parseSuccessParseSuccess = Typed.TypedName (Core.Name "hydra.parsing.ParseSuccess") + -- | DSL accessor for the remainder field of hydra.parsing.ParseSuccess parseSuccessRemainder :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm String parseSuccessRemainder x = @@ -165,6 +223,10 @@ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.parsing.Parser"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.parsing.Parser +parserParser :: Typed.TypedName (Parsing.Parser a) +parserParser = Typed.TypedName (Core.Name "hydra.parsing.Parser") -- | DSL accessor for the body of hydra.parsing.Parser unParser :: Typed.TypedTerm (Parsing.Parser a) -> Typed.TypedTerm (String -> Parsing.ParseResult a) diff --git a/src/main/haskell/Hydra/Dsl/Paths.hs b/src/main/haskell/Hydra/Dsl/Paths.hs --- a/src/main/haskell/Hydra/Dsl/Paths.hs +++ b/src/main/haskell/Hydra/Dsl/Paths.hs @@ -5,7 +5,9 @@ module Hydra.Dsl.Paths where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Paths as DecodePaths import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Paths as EncodePaths import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) @@ -45,6 +47,10 @@ Core.projectionFieldName = (Core.Name "source")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtermEdge +subtermEdgeSubtermEdge :: Typed.TypedName Paths.SubtermEdge +subtermEdgeSubtermEdge = Typed.TypedName (Core.Name "hydra.paths.SubtermEdge") + -- | DSL accessor for the target field of hydra.paths.SubtermEdge subtermEdgeTarget :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermNode subtermEdgeTarget x = @@ -157,6 +163,10 @@ Core.projectionFieldName = (Core.Name "nodes")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtermGraph +subtermGraphSubtermGraph :: Typed.TypedName Paths.SubtermGraph +subtermGraphSubtermGraph = Typed.TypedName (Core.Name "hydra.paths.SubtermGraph") + -- | DSL updater for the edges field of hydra.paths.SubtermGraph subtermGraphWithEdges :: Typed.TypedTerm Paths.SubtermGraph -> Typed.TypedTerm [Paths.SubtermEdge] -> Typed.TypedTerm Paths.SubtermGraph subtermGraphWithEdges original newVal = @@ -234,6 +244,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtermNode +subtermNodeSubtermNode :: Typed.TypedName Paths.SubtermNode +subtermNodeSubtermNode = Typed.TypedName (Core.Name "hydra.paths.SubtermNode") + -- | DSL updater for the id field of hydra.paths.SubtermNode subtermNodeWithId :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtermNode subtermNodeWithId original newVal = @@ -313,6 +327,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtermPath +subtermPathSubtermPath :: Typed.TypedName Paths.SubtermPath +subtermPathSubtermPath = Typed.TypedName (Core.Name "hydra.paths.SubtermPath") + -- | DSL injection for the annotatedBody variant of hydra.paths.SubtermStep subtermStepAnnotatedBody :: Typed.TypedTerm Paths.SubtermStep subtermStepAnnotatedBody = @@ -439,6 +457,10 @@ Core.fieldName = (Core.Name "setElement"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.paths.SubtermStep +subtermStepSubtermStep :: Typed.TypedName Paths.SubtermStep +subtermStepSubtermStep = Typed.TypedName (Core.Name "hydra.paths.SubtermStep") + -- | DSL injection for the sumTerm variant of hydra.paths.SubtermStep subtermStepSumTerm :: Typed.TypedTerm Paths.SubtermStep subtermStepSumTerm = @@ -527,6 +549,10 @@ Core.projectionFieldName = (Core.Name "source")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtypeEdge +subtypeEdgeSubtypeEdge :: Typed.TypedName Paths.SubtypeEdge +subtypeEdgeSubtypeEdge = Typed.TypedName (Core.Name "hydra.paths.SubtypeEdge") + -- | DSL accessor for the target field of hydra.paths.SubtypeEdge subtypeEdgeTarget :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypeNode subtypeEdgeTarget x = @@ -639,6 +665,10 @@ Core.projectionFieldName = (Core.Name "nodes")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtypeGraph +subtypeGraphSubtypeGraph :: Typed.TypedName Paths.SubtypeGraph +subtypeGraphSubtypeGraph = Typed.TypedName (Core.Name "hydra.paths.SubtypeGraph") + -- | DSL updater for the edges field of hydra.paths.SubtypeGraph subtypeGraphWithEdges :: Typed.TypedTerm Paths.SubtypeGraph -> Typed.TypedTerm [Paths.SubtypeEdge] -> Typed.TypedTerm Paths.SubtypeGraph subtypeGraphWithEdges original newVal = @@ -716,6 +746,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtypeNode +subtypeNodeSubtypeNode :: Typed.TypedName Paths.SubtypeNode +subtypeNodeSubtypeNode = Typed.TypedName (Core.Name "hydra.paths.SubtypeNode") + -- | DSL updater for the id field of hydra.paths.SubtypeNode subtypeNodeWithId :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtypeNode subtypeNodeWithId original newVal = @@ -795,6 +829,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.paths.SubtypePath +subtypePathSubtypePath :: Typed.TypedName Paths.SubtypePath +subtypePathSubtypePath = Typed.TypedName (Core.Name "hydra.paths.SubtypePath") + -- | DSL injection for the annotatedBody variant of hydra.paths.SubtypeStep subtypeStepAnnotatedBody :: Typed.TypedTerm Paths.SubtypeStep subtypeStepAnnotatedBody = @@ -938,6 +976,10 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "setElement"), Core.fieldTerm = Core.TermUnit}})) + +-- | DSL name token for hydra.paths.SubtypeStep +subtypeStepSubtypeStep :: Typed.TypedName Paths.SubtypeStep +subtypeStepSubtypeStep = Typed.TypedName (Core.Name "hydra.paths.SubtypeStep") -- | DSL injection for the unionField variant of hydra.paths.SubtypeStep subtypeStepUnionField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeStep diff --git a/src/main/haskell/Hydra/Dsl/Predicates.hs b/src/main/haskell/Hydra/Dsl/Predicates.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Predicates.hs @@ -0,0 +1,213 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.predicates + +module Hydra.Dsl.Predicates where + +import qualified Hydra.Arity as Arity +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Decode.Core as DecodeCore +import qualified Hydra.Dependencies as Dependencies +import qualified Hydra.Docs as Docs +import qualified Hydra.Dsl.Arity as DslArity +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.Dependencies as DslDependencies +import qualified Hydra.Dsl.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Lexical as DslLexical +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Rewriting as DslRewriting +import qualified Hydra.Dsl.Scoping as DslScoping +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Predicates as Predicates +import qualified Hydra.Query as Query +import qualified Hydra.Reflect as Reflect +import qualified Hydra.Relational as Relational +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Scoping as Scoping +import qualified Hydra.Strip as Strip +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | DSL reference to hydra.predicates.isComplexBinding +isComplexBinding :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm Bool +isComplexBinding arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isComplexBinding")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.predicates.isComplexTerm +isComplexTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isComplexTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isComplexTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.predicates.isComplexVariable +isComplexVariable :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Bool +isComplexVariable arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isComplexVariable")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.predicates.isEncodedTerm +isEncodedTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isEncodedTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isEncodedTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isEncodedType +isEncodedType :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isEncodedType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isEncodedType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isEnumRowType +isEnumRowType :: Typed.TypedTerm [Core.FieldType] -> Typed.TypedTerm Bool +isEnumRowType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isEnumRowType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isEnumType +isEnumType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +isEnumType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isEnumType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isNominalType +isNominalType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +isNominalType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isNominalType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isSerializable +isSerializable :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm (Either Errors.Error Bool) +isSerializable 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.predicates.isSerializable")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.predicates.isSerializableByName +isSerializableByName :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Bool) +isSerializableByName 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.predicates.isSerializableByName")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.predicates.isSerializableType +isSerializableType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +isSerializableType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isSerializableType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isTrivialTerm +isTrivialTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isTrivialTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isTrivialTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isType +isType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +isType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isUnitTerm +isUnitTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isUnitTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isUnitTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.isUnitType +isUnitType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +isUnitType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.isUnitType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.predicates.typeDependencies +typeDependencies :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Bool -> Typed.TypedTerm (Core.Type -> Core.Type) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (M.Map Core.Name Core.Type)) +typeDependencies arg0 arg1 arg2 arg3 arg4 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.predicates.typeDependencies")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})) diff --git a/src/main/haskell/Hydra/Dsl/Query.hs b/src/main/haskell/Hydra/Dsl/Query.hs --- a/src/main/haskell/Hydra/Dsl/Query.hs +++ b/src/main/haskell/Hydra/Dsl/Query.hs @@ -5,12 +5,18 @@ module Hydra.Dsl.Query where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Query as DecodeQuery import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Query as EncodeQuery import qualified Hydra.Query as Query import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +-- | DSL name token for hydra.query.ComparisonConstraint +comparisonConstraintComparisonConstraint :: Typed.TypedName Query.ComparisonConstraint +comparisonConstraintComparisonConstraint = Typed.TypedName (Core.Name "hydra.query.ComparisonConstraint") + -- | DSL injection for the equal variant of hydra.query.ComparisonConstraint comparisonConstraintEqual :: Typed.TypedTerm Query.ComparisonConstraint comparisonConstraintEqual = @@ -81,6 +87,10 @@ Core.fieldName = (Core.Name "in"), Core.fieldTerm = (Typed.unTypedTerm in_)}]})) +-- | DSL name token for hydra.query.Edge +edgeEdge :: Typed.TypedName Query.Edge +edgeEdge = Typed.TypedName (Core.Name "hydra.query.Edge") + -- | DSL accessor for the in field of hydra.query.Edge edgeIn :: Typed.TypedTerm Query.Edge -> Typed.TypedTerm (Maybe Core.Name) edgeIn x = @@ -202,6 +212,10 @@ Core.projectionFieldName = (Core.Name "graph")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.query.GraphPattern +graphPatternGraphPattern :: Typed.TypedName Query.GraphPattern +graphPatternGraphPattern = Typed.TypedName (Core.Name "hydra.query.GraphPattern") + -- | DSL accessor for the patterns field of hydra.query.GraphPattern graphPatternPatterns :: Typed.TypedTerm Query.GraphPattern -> Typed.TypedTerm [Query.Pattern] graphPatternPatterns x = @@ -245,6 +259,10 @@ Core.fieldName = (Core.Name "patterns"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) +-- | DSL name token for hydra.query.Node +nodeNode :: Typed.TypedName Query.Node +nodeNode = Typed.TypedName (Core.Name "hydra.query.Node") + -- | DSL injection for the term variant of hydra.query.Node nodeTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Query.Node nodeTerm x = @@ -294,6 +312,10 @@ Core.projectionFieldName = (Core.Name "left")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.query.PathEquation +pathEquationPathEquation :: Typed.TypedName Query.PathEquation +pathEquationPathEquation = Typed.TypedName (Core.Name "hydra.query.PathEquation") + -- | DSL accessor for the right field of hydra.query.PathEquation pathEquationRight :: Typed.TypedTerm Query.PathEquation -> Typed.TypedTerm Query.Path pathEquationRight x = @@ -346,6 +368,10 @@ Core.fieldName = (Core.Name "inverse"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.query.Path +pathPath :: Typed.TypedName Query.Path +pathPath = Typed.TypedName (Core.Name "hydra.query.Path") + -- | DSL injection for the regex variant of hydra.query.Path pathRegex :: Typed.TypedTerm Query.RegexSequence -> Typed.TypedTerm Query.Path pathRegex x = @@ -422,6 +448,10 @@ Core.projectionFieldName = (Core.Name "consequent")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.query.PatternImplication +patternImplicationPatternImplication :: Typed.TypedName Query.PatternImplication +patternImplicationPatternImplication = Typed.TypedName (Core.Name "hydra.query.PatternImplication") + -- | DSL updater for the antecedent field of hydra.query.PatternImplication patternImplicationWithAntecedent :: Typed.TypedTerm Query.PatternImplication -> Typed.TypedTerm Query.Pattern -> Typed.TypedTerm Query.PatternImplication patternImplicationWithAntecedent original newVal = @@ -465,6 +495,10 @@ Core.fieldName = (Core.Name "negation"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.query.Pattern +patternPattern :: Typed.TypedName Query.Pattern +patternPattern = Typed.TypedName (Core.Name "hydra.query.Pattern") + -- | DSL injection for the triple variant of hydra.query.Pattern patternTriple :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Pattern patternTriple x = @@ -496,6 +530,10 @@ Core.projectionFieldName = (Core.Name "patterns")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.query.Query +queryQuery :: Typed.TypedName Query.Query +queryQuery = Typed.TypedName (Core.Name "hydra.query.Query") + -- | DSL accessor for the variables field of hydra.query.Query queryVariables :: Typed.TypedTerm Query.Query -> Typed.TypedTerm [Query.Variable] queryVariables x = @@ -570,6 +608,10 @@ Core.projectionFieldName = (Core.Name "min")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.query.Range +rangeRange :: Typed.TypedName Query.Range +rangeRange = Typed.TypedName (Core.Name "hydra.query.Range") + -- | DSL updater for the max field of hydra.query.Range rangeWithMax :: Typed.TypedTerm Query.Range -> Typed.TypedTerm Int -> Typed.TypedTerm Query.Range rangeWithMax original newVal = @@ -649,6 +691,10 @@ Core.fieldName = (Core.Name "range"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.query.RegexQuantifier +regexQuantifierRegexQuantifier :: Typed.TypedName Query.RegexQuantifier +regexQuantifierRegexQuantifier = Typed.TypedName (Core.Name "hydra.query.RegexQuantifier") + -- | DSL injection for the zeroOrMore variant of hydra.query.RegexQuantifier regexQuantifierZeroOrMore :: Typed.TypedTerm Query.RegexQuantifier regexQuantifierZeroOrMore = @@ -698,6 +744,10 @@ Core.projectionFieldName = (Core.Name "quantifier")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.query.RegexSequence +regexSequenceRegexSequence :: Typed.TypedName Query.RegexSequence +regexSequenceRegexSequence = Typed.TypedName (Core.Name "hydra.query.RegexSequence") + -- | DSL updater for the path field of hydra.query.RegexSequence regexSequenceWithPath :: Typed.TypedTerm Query.RegexSequence -> Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.RegexSequence regexSequenceWithPath original newVal = @@ -759,6 +809,10 @@ Core.fieldName = (Core.Name "project"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.query.Step +stepStep :: Typed.TypedName Query.Step +stepStep = Typed.TypedName (Core.Name "hydra.query.Step") + -- | DSL constructor for hydra.query.TriplePattern triplePattern :: Typed.TypedTerm Query.Node -> Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.Node -> Typed.TypedTerm Query.TriplePattern triplePattern subject predicate object = @@ -802,6 +856,10 @@ Core.projectionFieldName = (Core.Name "subject")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.query.TriplePattern +triplePatternTriplePattern :: Typed.TypedName Query.TriplePattern +triplePatternTriplePattern = Typed.TypedName (Core.Name "hydra.query.TriplePattern") + -- | DSL updater for the object field of hydra.query.TriplePattern triplePatternWithObject :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Node -> Typed.TypedTerm Query.TriplePattern triplePatternWithObject original newVal = @@ -887,3 +945,7 @@ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.query.Variable"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.query.Variable +variableVariable :: Typed.TypedName Query.Variable +variableVariable = Typed.TypedName (Core.Name "hydra.query.Variable") diff --git a/src/main/haskell/Hydra/Dsl/Reduction.hs b/src/main/haskell/Hydra/Dsl/Reduction.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Reduction.hs @@ -0,0 +1,183 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.reduction + +module Hydra.Dsl.Reduction where + +import qualified Hydra.Annotations as Annotations +import qualified Hydra.Arity as Arity +import qualified Hydra.Ast as Ast +import qualified Hydra.Checking as Checking +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +import qualified Hydra.Dsl.Annotations as DslAnnotations +import qualified Hydra.Dsl.Arity as DslArity +import qualified Hydra.Dsl.Ast as DslAst +import qualified Hydra.Dsl.Checking as DslChecking +import qualified Hydra.Dsl.Coders as DslCoders +import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Dsl.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as DslErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Lexical as DslLexical +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Resolution as DslResolution +import qualified Hydra.Dsl.Rewriting as DslRewriting +import qualified Hydra.Dsl.Scoping as DslScoping +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Variables as DslVariables +import qualified Hydra.Dsl.Variants as DslVariants +import qualified Hydra.Error.Checking as ErrorChecking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.Extract.Core as ExtractCore +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Hoisting as Hoisting +import qualified Hydra.Inference as Inference +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Reduction as Reduction +import qualified Hydra.Relational as Relational +import qualified Hydra.Resolution as Resolution +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Scoping as Scoping +import qualified Hydra.Show.Core as ShowCore +import qualified Hydra.Show.Errors as ShowErrors +import qualified Hydra.Strip as Strip +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variables as Variables +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.reduction.alphaConvert +alphaConvert :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +alphaConvert 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.reduction.alphaConvert")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.reduction.betaReduceType +betaReduceType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error Core.Type) +betaReduceType 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.reduction.betaReduceType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.reduction.contractTerm +contractTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +contractTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.reduction.contractTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.reduction.countPrimitiveInvocations +countPrimitiveInvocations :: Typed.TypedTerm Bool +countPrimitiveInvocations = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.reduction.countPrimitiveInvocations")) + +-- | DSL reference to hydra.reduction.etaExpandTerm +etaExpandTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +etaExpandTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.reduction.etaExpandTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.reduction.etaExpandTypedTerm +etaExpandTypedTerm :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error Core.Term) +etaExpandTypedTerm 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.reduction.etaExpandTypedTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.reduction.etaExpansionArity +etaExpansionArity :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Int +etaExpansionArity arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.reduction.etaExpansionArity")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.reduction.etaReduceTerm +etaReduceTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +etaReduceTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.reduction.etaReduceTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.reduction.reduceTerm +reduceTerm :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Bool -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either Errors.Error Core.Term) +reduceTerm 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.reduction.reduceTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.reduction.termIsClosed +termIsClosed :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +termIsClosed arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.reduction.termIsClosed")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.reduction.termIsValue +termIsValue :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +termIsValue arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.reduction.termIsValue")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Refs.hs b/src/main/haskell/Hydra/Dsl/Refs.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Refs.hs @@ -0,0 +1,138 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.refs + +module Hydra.Dsl.Refs where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Names as Names +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Refs as Refs +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL reference to hydra.refs.decodeRef +decodeRef :: Typed.TypedTerm (Typed.TypedName t0) -> Typed.TypedTerm Core.Term +decodeRef arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.refs.decodeRef")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.refs.encodeList +encodeList :: Typed.TypedTerm (t0 -> Core.Term) -> Typed.TypedTerm [t0] -> Typed.TypedTerm Core.Term +encodeList arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.refs.encodeList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.refs.encodeMap +encodeMap :: Ord t0 => (Typed.TypedTerm (t0 -> Core.Term) -> Typed.TypedTerm (t1 -> Core.Term) -> Typed.TypedTerm (M.Map t0 t1) -> Typed.TypedTerm Core.Term) +encodeMap 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.refs.encodeMap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.refs.encodeOptional +encodeOptional :: Typed.TypedTerm (t0 -> Core.Term) -> Typed.TypedTerm (Maybe t0) -> Typed.TypedTerm Core.Term +encodeOptional arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.refs.encodeOptional")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.refs.encodePair +encodePair :: Typed.TypedTerm (t0 -> Core.Term) -> Typed.TypedTerm (t1 -> Core.Term) -> Typed.TypedTerm (t0, t1) -> Typed.TypedTerm Core.Term +encodePair 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.refs.encodePair")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.refs.encodeRef +encodeRef :: Typed.TypedTerm (Typed.TypedName t0) -> Typed.TypedTerm Core.Term +encodeRef arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.refs.encodeRef")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.refs.encodeSet +encodeSet :: Ord t0 => (Typed.TypedTerm (t0 -> Core.Term) -> Typed.TypedTerm (S.Set t0) -> Typed.TypedTerm Core.Term) +encodeSet arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.refs.encodeSet")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.refs.showRef +showRef :: Typed.TypedTerm (Typed.TypedName t0) -> Typed.TypedTerm Core.Term +showRef arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.refs.showRef")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Relational.hs b/src/main/haskell/Hydra/Dsl/Relational.hs --- a/src/main/haskell/Hydra/Dsl/Relational.hs +++ b/src/main/haskell/Hydra/Dsl/Relational.hs @@ -5,7 +5,11 @@ module Hydra.Dsl.Relational where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Relational as DecodeRelational import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Relational as EncodeRelational +import qualified Hydra.Errors as Errors +import qualified Hydra.Graph as Graph import qualified Hydra.Relational as Relational import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) @@ -20,6 +24,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.relational.ColumnName"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.relational.ColumnName +columnNameColumnName :: Typed.TypedName Relational.ColumnName +columnNameColumnName = Typed.TypedName (Core.Name "hydra.relational.ColumnName") + -- | DSL constructor for hydra.relational.ColumnSchema columnSchema :: Typed.TypedTerm Relational.ColumnName -> Typed.TypedTerm t -> Typed.TypedTerm (Relational.ColumnSchema t) columnSchema name domain = @@ -33,6 +41,10 @@ Core.fieldName = (Core.Name "domain"), Core.fieldTerm = (Typed.unTypedTerm domain)}]})) +-- | DSL name token for hydra.relational.ColumnSchema +columnSchemaColumnSchema :: Typed.TypedName (Relational.ColumnSchema t) +columnSchemaColumnSchema = Typed.TypedName (Core.Name "hydra.relational.ColumnSchema") + -- | DSL accessor for the domain field of hydra.relational.ColumnSchema columnSchemaDomain :: Typed.TypedTerm (Relational.ColumnSchema t) -> Typed.TypedTerm t columnSchemaDomain x = @@ -85,6 +97,76 @@ Core.projectionFieldName = (Core.Name "domain")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) +-- | DSL composition builder for the decoder of hydra.relational.ColumnSchema +decodeColumnSchema :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.ColumnSchema t)) +decodeColumnSchema t = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.columnSchema")), + Core.applicationArgument = (Typed.unTypedTerm t)})) + +-- | DSL composition builder for the decoder of hydra.relational.Relation +decodeRelation :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Relation v)) +decodeRelation v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.relation")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + +-- | DSL composition builder for the decoder of hydra.relational.RelationSchema +decodeRelationSchema :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError t) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.RelationSchema t)) +decodeRelationSchema t = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.relationSchema")), + Core.applicationArgument = (Typed.unTypedTerm t)})) + +-- | DSL composition builder for the decoder of hydra.relational.Relationship +decodeRelationship :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Relationship v)) +decodeRelationship v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.relationship")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + +-- | DSL composition builder for the decoder of hydra.relational.Row +decodeRow :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Row v)) +decodeRow v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.row")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + +-- | DSL composition builder for the encoder of hydra.relational.ColumnSchema +encodeColumnSchema :: Typed.TypedTerm (t -> Core.Term) -> Typed.TypedTerm (Relational.ColumnSchema t -> Core.Term) +encodeColumnSchema t = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.columnSchema")), + Core.applicationArgument = (Typed.unTypedTerm t)})) + +-- | DSL composition builder for the encoder of hydra.relational.Relation +encodeRelation :: Typed.TypedTerm (v -> Core.Term) -> Typed.TypedTerm (Relational.Relation v -> Core.Term) +encodeRelation v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relation")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + +-- | DSL composition builder for the encoder of hydra.relational.RelationSchema +encodeRelationSchema :: Typed.TypedTerm (t -> Core.Term) -> Typed.TypedTerm (Relational.RelationSchema t -> Core.Term) +encodeRelationSchema t = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relationSchema")), + Core.applicationArgument = (Typed.unTypedTerm t)})) + +-- | DSL composition builder for the encoder of hydra.relational.Relationship +encodeRelationship :: Typed.TypedTerm (v -> Core.Term) -> Typed.TypedTerm (Relational.Relationship v -> Core.Term) +encodeRelationship v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relationship")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + +-- | DSL composition builder for the encoder of hydra.relational.Row +encodeRow :: Typed.TypedTerm (v -> Core.Term) -> Typed.TypedTerm (Relational.Row v -> Core.Term) +encodeRow v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.row")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + -- | DSL constructor for hydra.relational.ForeignKey foreignKey :: Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm (M.Map Relational.ColumnName Relational.ColumnName) -> Typed.TypedTerm Relational.ForeignKey foreignKey foreignRelation keys = @@ -98,6 +180,10 @@ Core.fieldName = (Core.Name "keys"), Core.fieldTerm = (Typed.unTypedTerm keys)}]})) +-- | DSL name token for hydra.relational.ForeignKey +foreignKeyForeignKey :: Typed.TypedName Relational.ForeignKey +foreignKeyForeignKey = Typed.TypedName (Core.Name "hydra.relational.ForeignKey") + -- | DSL accessor for the foreignRelation field of hydra.relational.ForeignKey foreignKeyForeignRelation :: Typed.TypedTerm Relational.ForeignKey -> Typed.TypedTerm Relational.RelationName foreignKeyForeignRelation x = @@ -157,6 +243,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.relational.PrimaryKey"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.relational.PrimaryKey +primaryKeyPrimaryKey :: Typed.TypedName Relational.PrimaryKey +primaryKeyPrimaryKey = Typed.TypedName (Core.Name "hydra.relational.PrimaryKey") + -- | DSL constructor for the hydra.relational.Relation wrapper relation :: Typed.TypedTerm [Relational.Row v] -> Typed.TypedTerm (Relational.Relation v) relation x = @@ -171,6 +261,14 @@ Core.wrappedTermTypeName = (Core.Name "hydra.relational.RelationName"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.relational.RelationName +relationNameRelationName :: Typed.TypedName Relational.RelationName +relationNameRelationName = Typed.TypedName (Core.Name "hydra.relational.RelationName") + +-- | DSL name token for hydra.relational.Relation +relationRelation :: Typed.TypedName (Relational.Relation v) +relationRelation = Typed.TypedName (Core.Name "hydra.relational.Relation") + -- | DSL constructor for hydra.relational.RelationSchema relationSchema :: Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm [Relational.ColumnSchema t] -> Typed.TypedTerm [Relational.PrimaryKey] -> Typed.TypedTerm [Relational.ForeignKey] -> Typed.TypedTerm (Relational.RelationSchema t) relationSchema name columns primaryKeys foreignKeys = @@ -226,6 +324,10 @@ Core.projectionFieldName = (Core.Name "primaryKeys")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.relational.RelationSchema +relationSchemaRelationSchema :: Typed.TypedName (Relational.RelationSchema t) +relationSchemaRelationSchema = Typed.TypedName (Core.Name "hydra.relational.RelationSchema") + -- | DSL updater for the columns field of hydra.relational.RelationSchema relationSchemaWithColumns :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm [Relational.ColumnSchema t] -> Typed.TypedTerm (Relational.RelationSchema t) relationSchemaWithColumns original newVal = @@ -357,12 +459,20 @@ Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relationship"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.relational.Relationship +relationshipRelationship :: Typed.TypedName (Relational.Relationship v) +relationshipRelationship = Typed.TypedName (Core.Name "hydra.relational.Relationship") + -- | DSL constructor for the hydra.relational.Row wrapper row :: Typed.TypedTerm [v] -> Typed.TypedTerm (Relational.Row v) row x = Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.relational.Row"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.relational.Row +rowRow :: Typed.TypedName (Relational.Row v) +rowRow = Typed.TypedName (Core.Name "hydra.relational.Row") -- | DSL accessor for the body of hydra.relational.ColumnName unColumnName :: Typed.TypedTerm Relational.ColumnName -> Typed.TypedTerm String diff --git a/src/main/haskell/Hydra/Dsl/Resolution.hs b/src/main/haskell/Hydra/Dsl/Resolution.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Resolution.hs @@ -0,0 +1,260 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.resolution + +module Hydra.Dsl.Resolution where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Lexical as DslLexical +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Scoping as DslScoping +import qualified Hydra.Dsl.Strip as DslStrip +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.Variables as DslVariables +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Names as Names +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Resolution as Resolution +import qualified Hydra.Scoping as Scoping +import qualified Hydra.Show.Core as ShowCore +import qualified Hydra.Strip as Strip +import qualified Hydra.Substitution as Substitution +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variables as Variables +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | DSL reference to hydra.resolution.dereferenceType +dereferenceType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (Maybe Core.Type)) +dereferenceType 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.resolution.dereferenceType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.resolution.fTypeIsPolymorphic +fTypeIsPolymorphic :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool +fTypeIsPolymorphic arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.fTypeIsPolymorphic")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.resolution.fieldMap +fieldMap :: Typed.TypedTerm [Core.Field] -> Typed.TypedTerm (M.Map Core.Name Core.Term) +fieldMap arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.fieldMap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.resolution.fieldTypeMap +fieldTypeMap :: Typed.TypedTerm [Core.FieldType] -> Typed.TypedTerm (M.Map Core.Name Core.Type) +fieldTypeMap arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.fieldTypeMap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.resolution.fieldTypes +fieldTypes :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either Errors.Error (M.Map Core.Name Core.Type)) +fieldTypes 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.resolution.fieldTypes")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.resolution.findFieldType +findFieldType :: Typed.TypedTerm t0 -> Typed.TypedTerm Core.Name -> Typed.TypedTerm [Core.FieldType] -> Typed.TypedTerm (Either Errors.Error Core.Type) +findFieldType 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.resolution.findFieldType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.resolution.fullyStripAndNormalizeType +fullyStripAndNormalizeType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +fullyStripAndNormalizeType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.fullyStripAndNormalizeType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.resolution.fullyStripType +fullyStripType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +fullyStripType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.fullyStripType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.resolution.instantiateType +instantiateType :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Core.Type, Typing.InferenceContext) +instantiateType arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.instantiateType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.resolution.instantiateTypeScheme +instantiateTypeScheme :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm (Core.TypeScheme, Typing.InferenceContext) +instantiateTypeScheme arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.instantiateTypeScheme")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.resolution.nominalApplication +nominalApplication :: Typed.TypedTerm Core.Name -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Core.Type +nominalApplication arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.nominalApplication")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.resolution.requireRecordType +requireRecordType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error [Core.FieldType]) +requireRecordType 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.resolution.requireRecordType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.resolution.requireRowType +requireRowType :: Typed.TypedTerm t0 -> Typed.TypedTerm String -> Typed.TypedTerm (Core.Type -> Maybe t1) -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error t1) +requireRowType arg0 arg1 arg2 arg3 arg4 = + 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.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.requireRowType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})), + Core.applicationArgument = (Typed.unTypedTerm arg4)})) + +-- | DSL reference to hydra.resolution.requireSchemaType +requireSchemaType :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error (Core.TypeScheme, Typing.InferenceContext)) +requireSchemaType 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.resolution.requireSchemaType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.resolution.requireType +requireType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.Type) +requireType 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.resolution.requireType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.resolution.requireUnionField +requireUnionField :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error Core.Type) +requireUnionField 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.resolution.requireUnionField")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.resolution.requireUnionType +requireUnionType :: Typed.TypedTerm t0 -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Name -> Typed.TypedTerm (Either Errors.Error [Core.FieldType]) +requireUnionType 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.resolution.requireUnionType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.resolution.resolveType +resolveType :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Maybe Core.Type) +resolveType arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.resolveType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.resolution.typeToTypeScheme +typeToTypeScheme :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.TypeScheme +typeToTypeScheme arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.resolution.typeToTypeScheme")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Rewriting.hs b/src/main/haskell/Hydra/Dsl/Rewriting.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Rewriting.hs @@ -0,0 +1,261 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.rewriting + +module Hydra.Dsl.Rewriting where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Scoping as DslScoping +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Scoping as Scoping +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.rewriting.applyInsideTypeLambdasAndAnnotations +applyInsideTypeLambdasAndAnnotations :: Typed.TypedTerm (Core.Term -> Core.Term) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +applyInsideTypeLambdasAndAnnotations arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.applyInsideTypeLambdasAndAnnotations")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.rewriting.foldOverTerm +foldOverTerm :: Typed.TypedTerm Coders.TraversalOrder -> Typed.TypedTerm (t0 -> Core.Term -> t0) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm t0 +foldOverTerm 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.rewriting.foldOverTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.rewriting.foldOverType +foldOverType :: Typed.TypedTerm Coders.TraversalOrder -> Typed.TypedTerm (t0 -> Core.Type -> t0) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Type -> Typed.TypedTerm t0 +foldOverType 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.rewriting.foldOverType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.rewriting.foldTermWithGraphAndPath +foldTermWithGraphAndPath :: Typed.TypedTerm ((t0 -> Core.Term -> t0) -> [Paths.SubtermStep] -> Graph.Graph -> t0 -> Core.Term -> t0) -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm t0 +foldTermWithGraphAndPath 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.rewriting.foldTermWithGraphAndPath")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.rewriting.mapBeneathTypeAnnotations +mapBeneathTypeAnnotations :: Typed.TypedTerm (Core.Type -> Core.Type) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +mapBeneathTypeAnnotations arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.mapBeneathTypeAnnotations")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.rewriting.rewriteAndFoldTerm +rewriteAndFoldTerm :: Typed.TypedTerm ((t0 -> Core.Term -> (t0, Core.Term)) -> t0 -> Core.Term -> (t0, Core.Term)) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (t0, Core.Term) +rewriteAndFoldTerm 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.rewriting.rewriteAndFoldTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.rewriting.rewriteAndFoldTermWithGraph +rewriteAndFoldTermWithGraph :: Typed.TypedTerm ((t0 -> Core.Term -> (t0, Core.Term)) -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term)) -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (t0, Core.Term) +rewriteAndFoldTermWithGraph 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.rewriting.rewriteAndFoldTermWithGraph")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.rewriting.rewriteAndFoldTermWithGraphAndPath +rewriteAndFoldTermWithGraphAndPath :: Typed.TypedTerm ((t0 -> Core.Term -> (t0, Core.Term)) -> [Paths.SubtermStep] -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term)) -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (t0, Core.Term) +rewriteAndFoldTermWithGraphAndPath 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.rewriting.rewriteAndFoldTermWithGraphAndPath")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})), + Core.applicationArgument = (Typed.unTypedTerm arg3)})) + +-- | DSL reference to hydra.rewriting.rewriteAndFoldTermWithPath +rewriteAndFoldTermWithPath :: Typed.TypedTerm (([Paths.SubtermStep] -> t0 -> Core.Term -> (t0, Core.Term)) -> [Paths.SubtermStep] -> t0 -> Core.Term -> (t0, Core.Term)) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (t0, Core.Term) +rewriteAndFoldTermWithPath 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.rewriting.rewriteAndFoldTermWithPath")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.rewriting.rewriteTerm +rewriteTerm :: Typed.TypedTerm ((Core.Term -> Core.Term) -> Core.Term -> Core.Term) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +rewriteTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.rewriteTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.rewriting.rewriteTermM +rewriteTermM :: Typed.TypedTerm ((Core.Term -> Either t0 Core.Term) -> Core.Term -> Either t0 Core.Term) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t0 Core.Term) +rewriteTermM arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.rewriteTermM")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.rewriting.rewriteTermWithContext +rewriteTermWithContext :: Typed.TypedTerm ((t0 -> Core.Term -> Core.Term) -> t0 -> Core.Term -> Core.Term) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +rewriteTermWithContext 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.rewriting.rewriteTermWithContext")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.rewriting.rewriteTermWithContextM +rewriteTermWithContextM :: Typed.TypedTerm ((t0 -> Core.Term -> Either t1 Core.Term) -> t0 -> Core.Term -> Either t1 Core.Term) -> Typed.TypedTerm t0 -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either t1 Core.Term) +rewriteTermWithContextM 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.rewriting.rewriteTermWithContextM")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.rewriting.rewriteTermWithGraph +rewriteTermWithGraph :: Typed.TypedTerm ((Core.Term -> t0) -> Graph.Graph -> Core.Term -> t0) -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm t0 +rewriteTermWithGraph 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.rewriting.rewriteTermWithGraph")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.rewriting.rewriteType +rewriteType :: Typed.TypedTerm ((Core.Type -> Core.Type) -> Core.Type -> Core.Type) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +rewriteType arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.rewriteType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.rewriting.rewriteTypeM +rewriteTypeM :: Typed.TypedTerm ((Core.Type -> Either t0 Core.Type) -> Core.Type -> Either t0 Core.Type) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Either t0 Core.Type) +rewriteTypeM arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.rewriteTypeM")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.rewriting.subterms +subterms :: Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Term] +subterms arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.subterms")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.rewriting.subtermsWithSteps +subtermsWithSteps :: Typed.TypedTerm Core.Term -> Typed.TypedTerm [(Paths.SubtermStep, Core.Term)] +subtermsWithSteps arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.subtermsWithSteps")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.rewriting.subtypes +subtypes :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Core.Type] +subtypes arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.subtypes")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Scoping.hs b/src/main/haskell/Hydra/Dsl/Scoping.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Scoping.hs @@ -0,0 +1,130 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.scoping + +module Hydra.Dsl.Scoping where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Scoping as Scoping +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.scoping.extendGraphForLambda +extendGraphForLambda :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Lambda -> Typed.TypedTerm Graph.Graph +extendGraphForLambda arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.scoping.extendGraphForLambda")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.scoping.extendGraphForLet +extendGraphForLet :: Typed.TypedTerm (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Let -> Typed.TypedTerm Graph.Graph +extendGraphForLet 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.scoping.extendGraphForLet")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.scoping.extendGraphForTypeLambda +extendGraphForTypeLambda :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm Graph.Graph +extendGraphForTypeLambda arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.scoping.extendGraphForTypeLambda")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.scoping.extendGraphWithBindings +extendGraphWithBindings :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Graph.Graph +extendGraphWithBindings arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.scoping.extendGraphWithBindings")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.scoping.fTypeToTypeScheme +fTypeToTypeScheme :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.TypeScheme +fTypeToTypeScheme arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.scoping.fTypeToTypeScheme")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.scoping.termSignatureToTypeScheme +termSignatureToTypeScheme :: Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm Core.TypeScheme +termSignatureToTypeScheme arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.scoping.termSignatureToTypeScheme")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.scoping.typeSchemeToFType +typeSchemeToFType :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Core.Type +typeSchemeToFType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.scoping.typeSchemeToFType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.scoping.typeSchemeToTermSignature +typeSchemeToTermSignature :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Typing.TermSignature +typeSchemeToTermSignature arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.scoping.typeSchemeToTermSignature")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Serialization.hs b/src/main/haskell/Hydra/Dsl/Serialization.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Serialization.hs @@ -0,0 +1,512 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.serialization + +module Hydra.Dsl.Serialization where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Serialization as Serialization +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.serialization.angleBraces +angleBraces :: Typed.TypedTerm Ast.Brackets +angleBraces = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.angleBraces")) + +-- | DSL reference to hydra.serialization.angleBracesList +angleBracesList :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +angleBracesList arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.angleBracesList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.bracesListAdaptive +bracesListAdaptive :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +bracesListAdaptive arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.bracesListAdaptive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.bracketList +bracketList :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +bracketList arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.bracketList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.bracketListAdaptive +bracketListAdaptive :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +bracketListAdaptive arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.bracketListAdaptive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.brackets +brackets :: Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +brackets 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.serialization.brackets")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.serialization.chooseLayout +chooseLayout :: Typed.TypedTerm Int -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +chooseLayout 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.serialization.chooseLayout")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.serialization.commaSep +commaSep :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +commaSep arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.commaSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.commaSepAdaptive +commaSepAdaptive :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +commaSepAdaptive arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.commaSepAdaptive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.cst +cst :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Expr +cst arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.cst")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.curlyBlock +curlyBlock :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +curlyBlock arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.curlyBlock")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.curlyBraces +curlyBraces :: Typed.TypedTerm Ast.Brackets +curlyBraces = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.curlyBraces")) + +-- | DSL reference to hydra.serialization.curlyBracesList +curlyBracesList :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +curlyBracesList 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.serialization.curlyBracesList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.serialization.customIndent +customIndent :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String +customIndent arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.customIndent")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.customIndentBlock +customIndentBlock :: Typed.TypedTerm String -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +customIndentBlock arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.customIndentBlock")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.dotSep +dotSep :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +dotSep arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.dotSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.doubleNewlineSep +doubleNewlineSep :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +doubleNewlineSep arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.doubleNewlineSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.doubleSpace +doubleSpace :: Typed.TypedTerm String +doubleSpace = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.doubleSpace")) + +-- | DSL reference to hydra.serialization.expressionLength +expressionLength :: Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Int +expressionLength arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.expressionLength")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.fullBlockStyle +fullBlockStyle :: Typed.TypedTerm Ast.BlockStyle +fullBlockStyle = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.fullBlockStyle")) + +-- | DSL reference to hydra.serialization.halfBlockStyle +halfBlockStyle :: Typed.TypedTerm Ast.BlockStyle +halfBlockStyle = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.halfBlockStyle")) + +-- | DSL reference to hydra.serialization.ifx +ifx :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +ifx 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.serialization.ifx")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.serialization.indent +indent :: Typed.TypedTerm String -> Typed.TypedTerm String +indent arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.indent")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.indentBlock +indentBlock :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +indentBlock arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.indentBlock")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.indentSubsequentLines +indentSubsequentLines :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +indentSubsequentLines arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.indentSubsequentLines")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.infixWs +infixWs :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +infixWs 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.serialization.infixWs")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.serialization.infixWsList +infixWsList :: Typed.TypedTerm String -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +infixWsList arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.infixWsList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.inlineStyle +inlineStyle :: Typed.TypedTerm Ast.BlockStyle +inlineStyle = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.inlineStyle")) + +-- | DSL reference to hydra.serialization.maxLineWidth +maxLineWidth :: Typed.TypedTerm Int +maxLineWidth = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.maxLineWidth")) + +-- | DSL reference to hydra.serialization.newlineSep +newlineSep :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +newlineSep arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.newlineSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.noPadding +noPadding :: Typed.TypedTerm Ast.Padding +noPadding = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.noPadding")) + +-- | DSL reference to hydra.serialization.noSep +noSep :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +noSep arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.noSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.num +num :: Typed.TypedTerm Int -> Typed.TypedTerm Ast.Expr +num arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.num")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.op +op :: Typed.TypedTerm String -> Typed.TypedTerm Int -> Typed.TypedTerm Ast.Associativity -> Typed.TypedTerm Ast.Op +op 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.serialization.op")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.serialization.orOp +orOp :: Typed.TypedTerm Bool -> Typed.TypedTerm Ast.Op +orOp arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.orOp")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.orSep +orSep :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +orSep arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.orSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.parenList +parenList :: Typed.TypedTerm Bool -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +parenList arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.parenList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.parenListAdaptive +parenListAdaptive :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +parenListAdaptive arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.parenListAdaptive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.parens +parens :: Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +parens arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.parens")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.parentheses +parentheses :: Typed.TypedTerm Ast.Brackets +parentheses = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.parentheses")) + +-- | DSL reference to hydra.serialization.parenthesize +parenthesize :: Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +parenthesize arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.parenthesize")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.prefix +prefix :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +prefix arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.prefix")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.printExpr +printExpr :: Typed.TypedTerm Ast.Expr -> Typed.TypedTerm String +printExpr arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.printExpr")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.semicolonSep +semicolonSep :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +semicolonSep arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.semicolonSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.sep +sep :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +sep arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.sep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.spaceSep +spaceSep :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +spaceSep arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.spaceSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.spaceSepAdaptive +spaceSepAdaptive :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +spaceSepAdaptive arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.spaceSepAdaptive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.squareBrackets +squareBrackets :: Typed.TypedTerm Ast.Brackets +squareBrackets = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.serialization.squareBrackets")) + +-- | DSL reference to hydra.serialization.structuralSep +structuralSep :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +structuralSep arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.structuralSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.structuralSpaceSep +structuralSpaceSep :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +structuralSpaceSep arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.structuralSpaceSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.suffix +suffix :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +suffix arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.suffix")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.sym +sym :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Symbol +sym arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.sym")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.symbolSep +symbolSep :: Typed.TypedTerm String -> Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +symbolSep 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.serialization.symbolSep")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.serialization.tabIndent +tabIndent :: Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +tabIndent arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.tabIndent")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.tabIndentDoubleSpace +tabIndentDoubleSpace :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +tabIndentDoubleSpace arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.tabIndentDoubleSpace")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.tabIndentSingleSpace +tabIndentSingleSpace :: Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.Expr +tabIndentSingleSpace arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.tabIndentSingleSpace")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.unsupportedType +unsupportedType :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Expr +unsupportedType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.unsupportedType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.unsupportedVariant +unsupportedVariant :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Ast.Expr +unsupportedVariant arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.unsupportedVariant")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.serialization.withComma +withComma :: Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +withComma arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.withComma")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.serialization.withSemi +withSemi :: Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr +withSemi arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.serialization.withSemi")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Show/Docs.hs b/src/main/haskell/Hydra/Dsl/Show/Docs.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Show/Docs.hs @@ -0,0 +1,127 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.show.docs + +module Hydra.Dsl.Show.Docs where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Read.Docs as ReadDocs +import qualified Hydra.Relational as Relational +import qualified Hydra.Show.Docs as ShowDocs +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.show.docs.definitionReference +definitionReference :: Typed.TypedTerm Packaging.DefinitionReference -> Typed.TypedTerm String +definitionReference arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.definitionReference")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.show.docs.docSegment +docSegment :: Typed.TypedTerm Docs.DocSegment -> Typed.TypedTerm String +docSegment arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.docSegment")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.show.docs.docSegmentWith +docSegmentWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm Docs.DocSegment -> Typed.TypedTerm String +docSegmentWith arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.docSegmentWith")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.show.docs.docSegments +docSegments :: Typed.TypedTerm [Docs.DocSegment] -> Typed.TypedTerm String +docSegments arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.docSegments")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.show.docs.docSegmentsWith +docSegmentsWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm [Docs.DocSegment] -> Typed.TypedTerm String +docSegmentsWith arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.docSegmentsWith")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.show.docs.entityReference +entityReference :: Typed.TypedTerm Packaging.EntityReference -> Typed.TypedTerm String +entityReference arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.entityReference")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.show.docs.renderDocString +renderDocString :: Typed.TypedTerm String -> Typed.TypedTerm String +renderDocString arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.renderDocString")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.show.docs.renderDocStringWith +renderDocStringWith :: Typed.TypedTerm (Packaging.EntityReference -> String) -> Typed.TypedTerm String -> Typed.TypedTerm String +renderDocStringWith arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.show.docs.renderDocStringWith")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) diff --git a/src/main/haskell/Hydra/Dsl/Sorting.hs b/src/main/haskell/Hydra/Dsl/Sorting.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Sorting.hs @@ -0,0 +1,165 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.sorting + +module Hydra.Dsl.Sorting where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Constants as Constants +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +import qualified Hydra.Dsl.Ast as DslAst +import qualified Hydra.Dsl.Coders as DslCoders +import qualified Hydra.Dsl.Constants as DslConstants +import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Dsl.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Sorting as Sorting +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL reference to hydra.sorting.adjacencyListToMap +adjacencyListToMap :: Ord t0 => (Typed.TypedTerm [(t0, [t1])] -> Typed.TypedTerm (M.Map t0 [t1])) +adjacencyListToMap arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.adjacencyListToMap")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.sorting.adjacencyListsToGraph +adjacencyListsToGraph :: Typed.TypedTerm [(t0, [t0])] -> Typed.TypedTerm (M.Map Int [Int], (Int -> Maybe t0)) +adjacencyListsToGraph arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.adjacencyListsToGraph")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.sorting.createOrderingIsomorphism +createOrderingIsomorphism :: Typed.TypedTerm [t0] -> Typed.TypedTerm [t0] -> Typed.TypedTerm (Topology.OrderingIsomorphism t1) +createOrderingIsomorphism arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.createOrderingIsomorphism")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.sorting.findReachableNodes +findReachableNodes :: Ord t0 => (Typed.TypedTerm (t0 -> S.Set t0) -> Typed.TypedTerm t0 -> Typed.TypedTerm (S.Set t0)) +findReachableNodes arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.findReachableNodes")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.sorting.initialState +initialState :: Typed.TypedTerm Topology.TarjanState +initialState = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.sorting.initialState")) + +-- | DSL reference to hydra.sorting.popStackUntil +popStackUntil :: Typed.TypedTerm Int -> Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm ([Int], Topology.TarjanState) +popStackUntil arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.popStackUntil")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.sorting.propagateTags +propagateTags :: Ord t1 => (Typed.TypedTerm [(t0, [t0])] -> Typed.TypedTerm [(t0, [t1])] -> Typed.TypedTerm [(t0, (S.Set t1))]) +propagateTags arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.propagateTags")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.sorting.strongConnect +strongConnect :: Typed.TypedTerm (M.Map Int [Int]) -> Typed.TypedTerm Int -> Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm Topology.TarjanState +strongConnect 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.sorting.strongConnect")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.sorting.stronglyConnectedComponents +stronglyConnectedComponents :: Typed.TypedTerm (M.Map Int [Int]) -> Typed.TypedTerm [[Int]] +stronglyConnectedComponents arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.stronglyConnectedComponents")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.sorting.topologicalSort +topologicalSort :: Typed.TypedTerm [(t0, [t0])] -> Typed.TypedTerm (Either [[t0]] [t0]) +topologicalSort arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.topologicalSort")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.sorting.topologicalSortComponents +topologicalSortComponents :: Typed.TypedTerm [(t0, [t0])] -> Typed.TypedTerm [[t0]] +topologicalSortComponents arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.topologicalSortComponents")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.sorting.topologicalSortNodes +topologicalSortNodes :: Typed.TypedTerm (t0 -> t1) -> Typed.TypedTerm (t0 -> [t1]) -> Typed.TypedTerm [t0] -> Typed.TypedTerm [[t0]] +topologicalSortNodes 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.sorting.topologicalSortNodes")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) diff --git a/src/main/haskell/Hydra/Dsl/Strip.hs b/src/main/haskell/Hydra/Dsl/Strip.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Strip.hs @@ -0,0 +1,150 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.strip + +module Hydra.Dsl.Strip where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Rewriting as DslRewriting +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Strip as Strip +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.strip.deannotateAndDetypeTerm +deannotateAndDetypeTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +deannotateAndDetypeTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.deannotateAndDetypeTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.deannotateTerm +deannotateTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +deannotateTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.deannotateTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.deannotateType +deannotateType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +deannotateType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.deannotateType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.deannotateTypeParameters +deannotateTypeParameters :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +deannotateTypeParameters arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.deannotateTypeParameters")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.deannotateTypeRecursive +deannotateTypeRecursive :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +deannotateTypeRecursive arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.deannotateTypeRecursive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.deannotateTypeSchemeRecursive +deannotateTypeSchemeRecursive :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Core.TypeScheme +deannotateTypeSchemeRecursive arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.deannotateTypeSchemeRecursive")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.detypeTerm +detypeTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +detypeTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.detypeTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.removeTermAnnotations +removeTermAnnotations :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +removeTermAnnotations arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.removeTermAnnotations")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.removeTypeAnnotations +removeTypeAnnotations :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +removeTypeAnnotations arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.removeTypeAnnotations")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.removeTypeAnnotationsFromTerm +removeTypeAnnotationsFromTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +removeTypeAnnotationsFromTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.removeTypeAnnotationsFromTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.removeTypesFromTerm +removeTypesFromTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +removeTypesFromTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.removeTypesFromTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.strip.stripTypeLambdas +stripTypeLambdas :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +stripTypeLambdas arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.strip.stripTypeLambdas")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/System.hs b/src/main/haskell/Hydra/Dsl/System.hs --- a/src/main/haskell/Hydra/Dsl/System.hs +++ b/src/main/haskell/Hydra/Dsl/System.hs @@ -5,8 +5,10 @@ module Hydra.Dsl.System where import qualified Hydra.Core as Core +import qualified Hydra.Decode.System as DecodeSystem import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Encode.System as EncodeSystem import qualified Hydra.File as File import qualified Hydra.System as System import qualified Hydra.Typed as Typed @@ -43,6 +45,10 @@ Core.projectionFieldName = (Core.Name "arguments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.system.Command +commandCommand :: Typed.TypedName System.Command +commandCommand = Typed.TypedName (Core.Name "hydra.system.Command") + -- | DSL accessor for the environment field of hydra.system.Command commandEnvironment :: Typed.TypedTerm System.Command -> Typed.TypedTerm (Maybe (M.Map System.EnvironmentVariable String)) commandEnvironment x = @@ -201,6 +207,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.system.EnvironmentVariable"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.system.EnvironmentVariable +environmentVariableEnvironmentVariable :: Typed.TypedName System.EnvironmentVariable +environmentVariableEnvironmentVariable = Typed.TypedName (Core.Name "hydra.system.EnvironmentVariable") + -- | DSL constructor for hydra.system.ProcessResult processResult :: Typed.TypedTerm System.StatusCode -> Typed.TypedTerm B.ByteString -> Typed.TypedTerm B.ByteString -> Typed.TypedTerm System.ProcessResult processResult exitCode stdout stderr = @@ -226,6 +236,10 @@ Core.projectionFieldName = (Core.Name "exitCode")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.system.ProcessResult +processResultProcessResult :: Typed.TypedName System.ProcessResult +processResultProcessResult = Typed.TypedName (Core.Name "hydra.system.ProcessResult") + -- | DSL accessor for the stderr field of hydra.system.ProcessResult processResultStderr :: Typed.TypedTerm System.ProcessResult -> Typed.TypedTerm B.ByteString processResultStderr x = @@ -322,6 +336,10 @@ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.system.StatusCode"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.system.StatusCode +statusCodeStatusCode :: Typed.TypedName System.StatusCode +statusCodeStatusCode = Typed.TypedName (Core.Name "hydra.system.StatusCode") -- | DSL accessor for the body of hydra.system.EnvironmentVariable unEnvironmentVariable :: Typed.TypedTerm System.EnvironmentVariable -> Typed.TypedTerm String diff --git a/src/main/haskell/Hydra/Dsl/Tabular.hs b/src/main/haskell/Hydra/Dsl/Tabular.hs --- a/src/main/haskell/Hydra/Dsl/Tabular.hs +++ b/src/main/haskell/Hydra/Dsl/Tabular.hs @@ -5,8 +5,12 @@ module Hydra.Dsl.Tabular where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Tabular as DecodeTabular import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Encode.Tabular as EncodeTabular +import qualified Hydra.Errors as Errors +import qualified Hydra.Graph as Graph import qualified Hydra.Relational as Relational import qualified Hydra.Tabular as Tabular import qualified Hydra.Typed as Typed @@ -26,6 +30,10 @@ Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm type_)}]})) +-- | DSL name token for hydra.tabular.ColumnType +columnTypeColumnType :: Typed.TypedName Tabular.ColumnType +columnTypeColumnType = Typed.TypedName (Core.Name "hydra.tabular.ColumnType") + -- | DSL accessor for the name field of hydra.tabular.ColumnType columnTypeName :: Typed.TypedTerm Tabular.ColumnType -> Typed.TypedTerm Relational.ColumnName columnTypeName x = @@ -85,6 +93,38 @@ Core.wrappedTermTypeName = (Core.Name "hydra.tabular.DataRow"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.tabular.DataRow +dataRowDataRow :: Typed.TypedName (Tabular.DataRow v) +dataRowDataRow = Typed.TypedName (Core.Name "hydra.tabular.DataRow") + +-- | DSL composition builder for the decoder of hydra.tabular.DataRow +decodeDataRow :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Tabular.DataRow v)) +decodeDataRow v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.tabular.dataRow")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + +-- | DSL composition builder for the decoder of hydra.tabular.Table +decodeTable :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Tabular.Table v)) +decodeTable v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.tabular.table")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + +-- | DSL composition builder for the encoder of hydra.tabular.DataRow +encodeDataRow :: Typed.TypedTerm (v -> Core.Term) -> Typed.TypedTerm (Tabular.DataRow v -> Core.Term) +encodeDataRow v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.tabular.dataRow")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + +-- | DSL composition builder for the encoder of hydra.tabular.Table +encodeTable :: Typed.TypedTerm (v -> Core.Term) -> Typed.TypedTerm (Tabular.Table v -> Core.Term) +encodeTable v = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.tabular.table")), + Core.applicationArgument = (Typed.unTypedTerm v)})) + -- | DSL constructor for the hydra.tabular.HeaderRow wrapper headerRow :: Typed.TypedTerm [String] -> Typed.TypedTerm Tabular.HeaderRow headerRow x = @@ -92,6 +132,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.tabular.HeaderRow"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.tabular.HeaderRow +headerRowHeaderRow :: Typed.TypedName Tabular.HeaderRow +headerRowHeaderRow = Typed.TypedName (Core.Name "hydra.tabular.HeaderRow") + -- | DSL constructor for hydra.tabular.Table table :: Typed.TypedTerm (Maybe Tabular.HeaderRow) -> Typed.TypedTerm [Tabular.DataRow v] -> Typed.TypedTerm (Tabular.Table v) table header data_ = @@ -123,6 +167,10 @@ Core.projectionFieldName = (Core.Name "header")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.tabular.Table +tableTable :: Typed.TypedName (Tabular.Table v) +tableTable = Typed.TypedName (Core.Name "hydra.tabular.Table") + -- | DSL constructor for hydra.tabular.TableType tableType :: Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm [Tabular.ColumnType] -> Typed.TypedTerm Tabular.TableType tableType name columns = @@ -153,6 +201,10 @@ Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.tabular.TableType +tableTypeTableType :: Typed.TypedName Tabular.TableType +tableTypeTableType = Typed.TypedName (Core.Name "hydra.tabular.TableType") -- | DSL updater for the columns field of hydra.tabular.TableType tableTypeWithColumns :: Typed.TypedTerm Tabular.TableType -> Typed.TypedTerm [Tabular.ColumnType] -> Typed.TypedTerm Tabular.TableType diff --git a/src/main/haskell/Hydra/Dsl/Test/Transform.hs b/src/main/haskell/Hydra/Dsl/Test/Transform.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Test/Transform.hs @@ -0,0 +1,170 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.test.transform + +module Hydra.Dsl.Test.Transform where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Packaging as DslPackaging +import qualified Hydra.Dsl.Parsing as DslParsing +import qualified Hydra.Dsl.Paths as DslPaths +import qualified Hydra.Dsl.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Sorting as DslSorting +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Formatting as Formatting +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Sorting as Sorting +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Test.Transform as Transform +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.test.transform.addGenerationPrefix +addGenerationPrefix :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.ModuleName +addGenerationPrefix arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.addGenerationPrefix")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.buildConvertCaseCall +buildConvertCaseCall :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm String -> Typed.TypedTerm Core.Term +buildConvertCaseCall 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.test.transform.buildConvertCaseCall")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.test.transform.buildTopologicalSortCall +buildTopologicalSortCall :: Typed.TypedTerm [(Int, [Int])] -> Typed.TypedTerm Core.Term +buildTopologicalSortCall arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.buildTopologicalSortCall")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.buildTopologicalSortSCCCall +buildTopologicalSortSCCCall :: Typed.TypedTerm [(Int, [Int])] -> Typed.TypedTerm Core.Term +buildTopologicalSortSCCCall arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.buildTopologicalSortSCCCall")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.collectTestCases +collectTestCases :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm [Testing.TestCaseWithMetadata] +collectTestCases arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.collectTestCases")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.encodeAdjacencyList +encodeAdjacencyList :: Typed.TypedTerm [(Int, [Int])] -> Typed.TypedTerm Core.Term +encodeAdjacencyList arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.encodeAdjacencyList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.encodeCaseConvention +encodeCaseConvention :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Core.Term +encodeCaseConvention arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.encodeCaseConvention")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.encodeEitherListList +encodeEitherListList :: Typed.TypedTerm (Either [[Int]] [Int]) -> Typed.TypedTerm Core.Term +encodeEitherListList arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.encodeEitherListList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.encodeInt +encodeInt :: Typed.TypedTerm Int -> Typed.TypedTerm Core.Term +encodeInt arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.encodeInt")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.encodeIntList +encodeIntList :: Typed.TypedTerm [Int] -> Typed.TypedTerm Core.Term +encodeIntList arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.encodeIntList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.encodeListList +encodeListList :: Typed.TypedTerm [[Int]] -> Typed.TypedTerm Core.Term +encodeListList arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.encodeListList")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.transformModule +transformModule :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Packaging.Module +transformModule arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.transformModule")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.transformTestCase +transformTestCase :: Typed.TypedTerm t0 -> Typed.TypedTerm (Maybe t0) +transformTestCase arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.transformTestCase")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.test.transform.transformToCompiledTests +transformToCompiledTests :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm (Maybe Testing.TestGroup) +transformToCompiledTests arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.transform.transformToCompiledTests")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Test/Utils.hs b/src/main/haskell/Hydra/Dsl/Test/Utils.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Test/Utils.hs @@ -0,0 +1,95 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.test.utils + +module Hydra.Dsl.Test.Utils where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +import qualified Hydra.Dsl.Graph as DslGraph +import qualified Hydra.Dsl.Json.Model as JsonModel +import qualified Hydra.Dsl.Lexical as DslLexical +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Inference as Inference +import qualified Hydra.Json.Model as Model +import qualified Hydra.Lexical as Lexical +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Show.Errors as ShowErrors +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Test.Utils as Utils +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +-- | DSL reference to hydra.test.utils.inferTerm +inferTerm :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Either String Core.Term) +inferTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.utils.inferTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.test.utils.inferTestCase +inferTestCase :: Typed.TypedTerm t0 -> Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm (Either t1 Testing.TestCaseWithMetadata) +inferTestCase arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.utils.inferTestCase")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.test.utils.inferTestGroupTerms +inferTestGroupTerms :: Typed.TypedTerm t0 -> Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm (Either t1 Testing.TestGroup) +inferTestGroupTerms arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.test.utils.inferTestGroupTerms")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) diff --git a/src/main/haskell/Hydra/Dsl/Testing.hs b/src/main/haskell/Hydra/Dsl/Testing.hs --- a/src/main/haskell/Hydra/Dsl/Testing.hs +++ b/src/main/haskell/Hydra/Dsl/Testing.hs @@ -5,7 +5,9 @@ module Hydra.Dsl.Testing where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Testing as DecodeTesting import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Testing as EncodeTesting import qualified Hydra.Testing as Testing import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) @@ -33,6 +35,10 @@ Core.projectionFieldName = (Core.Name "actual")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.testing.EffectfulTestCase +effectfulTestCaseEffectfulTestCase :: Typed.TypedName Testing.EffectfulTestCase +effectfulTestCaseEffectfulTestCase = Typed.TypedName (Core.Name "hydra.testing.EffectfulTestCase") + -- | DSL accessor for the expected field of hydra.testing.EffectfulTestCase effectfulTestCaseExpected :: Typed.TypedTerm Testing.EffectfulTestCase -> Typed.TypedTerm (() -> String) effectfulTestCaseExpected x = @@ -83,6 +89,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.testing.Tag"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.testing.Tag +tagTag :: Typed.TypedName Testing.Tag +tagTag = Typed.TypedName (Core.Name "hydra.testing.Tag") + -- | DSL injection for the effectful variant of hydra.testing.TestCase testCaseEffectful :: Typed.TypedTerm Testing.EffectfulTestCase -> Typed.TypedTerm Testing.TestCase testCaseEffectful x = @@ -92,6 +102,10 @@ Core.fieldName = (Core.Name "effectful"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.testing.TestCase +testCaseTestCase :: Typed.TypedName Testing.TestCase +testCaseTestCase = Typed.TypedName (Core.Name "hydra.testing.TestCase") + -- | DSL injection for the universal variant of hydra.testing.TestCase testCaseUniversal :: Typed.TypedTerm Testing.UniversalTestCase -> Typed.TypedTerm Testing.TestCase testCaseUniversal x = @@ -156,6 +170,10 @@ Core.projectionFieldName = (Core.Name "tags")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.testing.TestCaseWithMetadata +testCaseWithMetadataTestCaseWithMetadata :: Typed.TypedName Testing.TestCaseWithMetadata +testCaseWithMetadataTestCaseWithMetadata = Typed.TypedName (Core.Name "hydra.testing.TestCaseWithMetadata") + -- | DSL updater for the case field of hydra.testing.TestCaseWithMetadata testCaseWithMetadataWithCase :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm Testing.TestCase -> Typed.TypedTerm Testing.TestCaseWithMetadata testCaseWithMetadataWithCase original newVal = @@ -335,6 +353,10 @@ Core.projectionFieldName = (Core.Name "subgroups")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.testing.TestGroup +testGroupTestGroup :: Typed.TypedName Testing.TestGroup +testGroupTestGroup = Typed.TypedName (Core.Name "hydra.testing.TestGroup") + -- | DSL updater for the cases field of hydra.testing.TestGroup testGroupWithCases :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm [Testing.TestCaseWithMetadata] -> Typed.TypedTerm Testing.TestGroup testGroupWithCases original newVal = @@ -496,6 +518,10 @@ Core.projectionTypeName = (Core.Name "hydra.testing.UniversalTestCase"), Core.projectionFieldName = (Core.Name "expected")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.testing.UniversalTestCase +universalTestCaseUniversalTestCase :: Typed.TypedName Testing.UniversalTestCase +universalTestCaseUniversalTestCase = Typed.TypedName (Core.Name "hydra.testing.UniversalTestCase") -- | DSL updater for the actual field of hydra.testing.UniversalTestCase universalTestCaseWithActual :: Typed.TypedTerm Testing.UniversalTestCase -> Typed.TypedTerm (() -> String) -> Typed.TypedTerm Testing.UniversalTestCase diff --git a/src/main/haskell/Hydra/Dsl/Time.hs b/src/main/haskell/Hydra/Dsl/Time.hs --- a/src/main/haskell/Hydra/Dsl/Time.hs +++ b/src/main/haskell/Hydra/Dsl/Time.hs @@ -5,7 +5,9 @@ module Hydra.Dsl.Time where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Time as DecodeTime import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Time as EncodeTime import qualified Hydra.Time as Time import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) @@ -42,6 +44,10 @@ Core.projectionTypeName = (Core.Name "hydra.time.Timespec"), Core.projectionFieldName = (Core.Name "seconds")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.time.Timespec +timespecTimespec :: Typed.TypedName Time.Timespec +timespecTimespec = Typed.TypedName (Core.Name "hydra.time.Timespec") -- | DSL updater for the nanoseconds field of hydra.time.Timespec timespecWithNanoseconds :: Typed.TypedTerm Time.Timespec -> Typed.TypedTerm I.Int64 -> Typed.TypedTerm Time.Timespec diff --git a/src/main/haskell/Hydra/Dsl/Topology.hs b/src/main/haskell/Hydra/Dsl/Topology.hs --- a/src/main/haskell/Hydra/Dsl/Topology.hs +++ b/src/main/haskell/Hydra/Dsl/Topology.hs @@ -5,7 +5,11 @@ module Hydra.Dsl.Topology where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Topology as DecodeTopology import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Topology as EncodeTopology +import qualified Hydra.Errors as Errors +import qualified Hydra.Graph as Graph import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) @@ -13,6 +17,20 @@ import qualified Data.Map as M import qualified Data.Set as S +-- | DSL composition builder for the decoder of hydra.topology.OrderingIsomorphism +decodeOrderingIsomorphism :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Topology.OrderingIsomorphism a)) +decodeOrderingIsomorphism a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.topology.orderingIsomorphism")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + +-- | DSL composition builder for the encoder of hydra.topology.OrderingIsomorphism +encodeOrderingIsomorphism :: Typed.TypedTerm (a -> Core.Term) -> Typed.TypedTerm (Topology.OrderingIsomorphism a -> Core.Term) +encodeOrderingIsomorphism a = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.topology.orderingIsomorphism")), + Core.applicationArgument = (Typed.unTypedTerm a)})) + -- | DSL constructor for hydra.topology.OrderingIsomorphism orderingIsomorphism :: Typed.TypedTerm ([a] -> [a]) -> Typed.TypedTerm ([a] -> [a]) -> Typed.TypedTerm (Topology.OrderingIsomorphism a) orderingIsomorphism encode decode = @@ -44,6 +62,10 @@ Core.projectionFieldName = (Core.Name "encode")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.topology.OrderingIsomorphism +orderingIsomorphismOrderingIsomorphism :: Typed.TypedName (Topology.OrderingIsomorphism a) +orderingIsomorphismOrderingIsomorphism = Typed.TypedName (Core.Name "hydra.topology.OrderingIsomorphism") + -- | DSL updater for the decode field of hydra.topology.OrderingIsomorphism orderingIsomorphismWithDecode :: Typed.TypedTerm (Topology.OrderingIsomorphism a) -> Typed.TypedTerm ([a] -> [a]) -> Typed.TypedTerm (Topology.OrderingIsomorphism a) orderingIsomorphismWithDecode original newVal = @@ -156,6 +178,10 @@ Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), Core.projectionFieldName = (Core.Name "stack")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.topology.TarjanState +tarjanStateTarjanState :: Typed.TypedName Topology.TarjanState +tarjanStateTarjanState = Typed.TypedName (Core.Name "hydra.topology.TarjanState") -- | DSL updater for the counter field of hydra.topology.TarjanState tarjanStateWithCounter :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm Int -> Typed.TypedTerm Topology.TarjanState diff --git a/src/main/haskell/Hydra/Dsl/Typing.hs b/src/main/haskell/Hydra/Dsl/Typing.hs --- a/src/main/haskell/Hydra/Dsl/Typing.hs +++ b/src/main/haskell/Hydra/Dsl/Typing.hs @@ -5,8 +5,12 @@ module Hydra.Dsl.Typing where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Typing as DecodeTyping import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Paths as DslPaths +import qualified Hydra.Encode.Typing as EncodeTyping +import qualified Hydra.Errors as Errors +import qualified Hydra.Graph as Graph import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -14,6 +18,20 @@ import qualified Data.Scientific as Sci import qualified Data.Map as M +-- | DSL composition builder for the decoder of hydra.typing.FunctionStructure +decodeFunctionStructure :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError env) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typing.FunctionStructure env)) +decodeFunctionStructure env = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.typing.functionStructure")), + Core.applicationArgument = (Typed.unTypedTerm env)})) + +-- | DSL composition builder for the encoder of hydra.typing.FunctionStructure +encodeFunctionStructure :: Typed.TypedTerm (env -> Core.Term) -> Typed.TypedTerm (Typing.FunctionStructure env -> Core.Term) +encodeFunctionStructure env = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.functionStructure")), + Core.applicationArgument = (Typed.unTypedTerm env)})) + -- | DSL constructor for hydra.typing.FunctionStructure functionStructure :: Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm env -> Typed.TypedTerm (Typing.FunctionStructure env) functionStructure typeParams params bindings body domains codomain environment = @@ -87,6 +105,10 @@ Core.projectionFieldName = (Core.Name "environment")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.FunctionStructure +functionStructureFunctionStructure :: Typed.TypedName (Typing.FunctionStructure env) +functionStructureFunctionStructure = Typed.TypedName (Core.Name "hydra.typing.FunctionStructure") + -- | DSL accessor for the params field of hydra.typing.FunctionStructure functionStructureParams :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Name] functionStructureParams x = @@ -491,6 +513,10 @@ Core.projectionFieldName = (Core.Name "freshTypeVariableCount")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.InferenceContext +inferenceContextInferenceContext :: Typed.TypedName Typing.InferenceContext +inferenceContextInferenceContext = Typed.TypedName (Core.Name "hydra.typing.InferenceContext") + -- | DSL accessor for the trace field of hydra.typing.InferenceContext inferenceContextTrace :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm [Paths.SubtermStep] inferenceContextTrace x = @@ -574,6 +600,10 @@ Core.projectionFieldName = (Core.Name "context")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.InferenceResult +inferenceResultInferenceResult :: Typed.TypedName Typing.InferenceResult +inferenceResultInferenceResult = Typed.TypedName (Core.Name "hydra.typing.InferenceResult") + -- | DSL accessor for the subst field of hydra.typing.InferenceResult inferenceResultSubst :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Typing.TypeSubst inferenceResultSubst x = @@ -837,6 +867,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.Parameter +parameterParameter :: Typed.TypedName Typing.Parameter +parameterParameter = Typed.TypedName (Core.Name "hydra.typing.Parameter") + -- | DSL accessor for the type field of hydra.typing.Parameter parameterType :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm Core.Type parameterType x = @@ -992,6 +1026,10 @@ Core.projectionFieldName = (Core.Name "description")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.Result +resultResult :: Typed.TypedName Typing.Result +resultResult = Typed.TypedName (Core.Name "hydra.typing.Result") + -- | DSL accessor for the type field of hydra.typing.Result resultType :: Typed.TypedTerm Typing.Result -> Typed.TypedTerm Core.Type resultType x = @@ -1069,6 +1107,10 @@ Core.projectionFieldName = (Core.Name "result")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.TermSignature +termSignatureTermSignature :: Typed.TypedName Typing.TermSignature +termSignatureTermSignature = Typed.TypedName (Core.Name "hydra.typing.TermSignature") + -- | DSL accessor for the typeParameters field of hydra.typing.TermSignature termSignatureTypeParameters :: Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm [Typing.TypeParameter] termSignatureTypeParameters x = @@ -1157,6 +1199,10 @@ Core.wrappedTermTypeName = (Core.Name "hydra.typing.TermSubst"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.TermSubst +termSubstTermSubst :: Typed.TypedName Typing.TermSubst +termSubstTermSubst = Typed.TypedName (Core.Name "hydra.typing.TermSubst") + -- | DSL constructor for hydra.typing.TypeClass typeClass :: Typed.TypedTerm String -> Typed.TypedTerm Typing.TypeClass typeClass description = @@ -1176,6 +1222,10 @@ Core.projectionFieldName = (Core.Name "description")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.TypeClass +typeClassTypeClass :: Typed.TypedName Typing.TypeClass +typeClassTypeClass = Typed.TypedName (Core.Name "hydra.typing.TypeClass") + -- | DSL updater for the description field of hydra.typing.TypeClass typeClassWithDescription :: Typed.TypedTerm Typing.TypeClass -> Typed.TypedTerm String -> Typed.TypedTerm Typing.TypeClass typeClassWithDescription original newVal = @@ -1229,6 +1279,10 @@ Core.projectionFieldName = (Core.Name "right")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.TypeConstraint +typeConstraintTypeConstraint :: Typed.TypedName Typing.TypeConstraint +typeConstraintTypeConstraint = Typed.TypedName (Core.Name "hydra.typing.TypeConstraint") + -- | DSL updater for the comment field of hydra.typing.TypeConstraint typeConstraintWithComment :: Typed.TypedTerm Typing.TypeConstraint -> Typed.TypedTerm String -> Typed.TypedTerm Typing.TypeConstraint typeConstraintWithComment original newVal = @@ -1332,6 +1386,10 @@ Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typing.TypeParameter +typeParameterTypeParameter :: Typed.TypedName Typing.TypeParameter +typeParameterTypeParameter = Typed.TypedName (Core.Name "hydra.typing.TypeParameter") + -- | DSL updater for the constraints field of hydra.typing.TypeParameter typeParameterWithConstraints :: Typed.TypedTerm Typing.TypeParameter -> Typed.TypedTerm [Core.TypeClassConstraint] -> Typed.TypedTerm Typing.TypeParameter typeParameterWithConstraints original newVal = @@ -1372,6 +1430,10 @@ Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.typing.TypeSubst"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.typing.TypeSubst +typeSubstTypeSubst :: Typed.TypedName Typing.TypeSubst +typeSubstTypeSubst = Typed.TypedName (Core.Name "hydra.typing.TypeSubst") -- | DSL accessor for the body of hydra.typing.TermSubst unTermSubst :: Typed.TypedTerm Typing.TermSubst -> Typed.TypedTerm (M.Map Core.Name Core.Term) diff --git a/src/main/haskell/Hydra/Dsl/Util.hs b/src/main/haskell/Hydra/Dsl/Util.hs --- a/src/main/haskell/Hydra/Dsl/Util.hs +++ b/src/main/haskell/Hydra/Dsl/Util.hs @@ -5,8 +5,12 @@ module Hydra.Dsl.Util where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Util as DecodeUtil import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Packaging as DslPackaging +import qualified Hydra.Encode.Util as EncodeUtil +import qualified Hydra.Errors as Errors +import qualified Hydra.Graph as Graph import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed import qualified Hydra.Util as Util @@ -23,6 +27,10 @@ Core.fieldName = (Core.Name "camel"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.util.CaseConvention +caseConventionCaseConvention :: Typed.TypedName Util.CaseConvention +caseConventionCaseConvention = Typed.TypedName (Core.Name "hydra.util.CaseConvention") + -- | DSL injection for the lowerSnake variant of hydra.util.CaseConvention caseConventionLowerSnake :: Typed.TypedTerm Util.CaseConvention caseConventionLowerSnake = @@ -50,6 +58,10 @@ Core.fieldName = (Core.Name "upperSnake"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.util.Comparison +comparisonComparison :: Typed.TypedName Util.Comparison +comparisonComparison = Typed.TypedName (Core.Name "hydra.util.Comparison") + -- | DSL injection for the equalTo variant of hydra.util.Comparison comparisonEqualTo :: Typed.TypedTerm Util.Comparison comparisonEqualTo = @@ -77,6 +89,20 @@ Core.fieldName = (Core.Name "lessThan"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL composition builder for the decoder of hydra.util.ModuleNames +decodeModuleNames :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError n) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Util.ModuleNames n)) +decodeModuleNames n = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.util.moduleNames")), + Core.applicationArgument = (Typed.unTypedTerm n)})) + +-- | DSL composition builder for the encoder of hydra.util.ModuleNames +encodeModuleNames :: Typed.TypedTerm (n -> Core.Term) -> Typed.TypedTerm (Util.ModuleNames n -> Core.Term) +encodeModuleNames n = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.moduleNames")), + Core.applicationArgument = (Typed.unTypedTerm n)})) + -- | DSL constructor for hydra.util.ModuleNames moduleNames :: Typed.TypedTerm (Packaging.ModuleName, n) -> Typed.TypedTerm (M.Map Packaging.ModuleName n) -> Typed.TypedTerm (Util.ModuleNames n) moduleNames focus mapping = @@ -108,6 +134,10 @@ Core.projectionFieldName = (Core.Name "mapping")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.util.ModuleNames +moduleNamesModuleNames :: Typed.TypedName (Util.ModuleNames n) +moduleNamesModuleNames = Typed.TypedName (Core.Name "hydra.util.ModuleNames") + -- | DSL updater for the focus field of hydra.util.ModuleNames moduleNamesWithFocus :: Typed.TypedTerm (Util.ModuleNames n) -> Typed.TypedTerm (Packaging.ModuleName, n) -> Typed.TypedTerm (Util.ModuleNames n) moduleNamesWithFocus original newVal = @@ -160,6 +190,10 @@ Core.fieldName = (Core.Name "bits"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.util.Precision +precisionPrecision :: Typed.TypedName Util.Precision +precisionPrecision = Typed.TypedName (Core.Name "hydra.util.Precision") + -- | DSL constructor for hydra.util.QualifiedName qualifiedName :: Typed.TypedTerm (Maybe Packaging.ModuleName) -> Typed.TypedTerm String -> Typed.TypedTerm Util.QualifiedName qualifiedName moduleName local = @@ -190,6 +224,10 @@ Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"), Core.projectionFieldName = (Core.Name "moduleName")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.util.QualifiedName +qualifiedNameQualifiedName :: Typed.TypedName Util.QualifiedName +qualifiedNameQualifiedName = Typed.TypedName (Core.Name "hydra.util.QualifiedName") -- | DSL updater for the local field of hydra.util.QualifiedName qualifiedNameWithLocal :: Typed.TypedTerm Util.QualifiedName -> Typed.TypedTerm String -> Typed.TypedTerm Util.QualifiedName diff --git a/src/main/haskell/Hydra/Dsl/Validation.hs b/src/main/haskell/Hydra/Dsl/Validation.hs --- a/src/main/haskell/Hydra/Dsl/Validation.hs +++ b/src/main/haskell/Hydra/Dsl/Validation.hs @@ -5,15 +5,33 @@ module Hydra.Dsl.Validation where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Validation as DecodeValidation import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Encode.Validation as EncodeValidation import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Errors as Errors +import qualified Hydra.Graph as Graph import qualified Hydra.Typed as Typed import qualified Hydra.Validation as Validation import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci import qualified Data.Set as S +-- | DSL composition builder for the decoder of hydra.validation.ValidationResult +decodeValidationResult :: Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError e) -> Typed.TypedTerm (Graph.Graph -> Core.Term -> Either Errors.DecodingError (Validation.ValidationResult e)) +decodeValidationResult e = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.validation.validationResult")), + Core.applicationArgument = (Typed.unTypedTerm e)})) + +-- | DSL composition builder for the encoder of hydra.validation.ValidationResult +encodeValidationResult :: Typed.TypedTerm (e -> Core.Term) -> Typed.TypedTerm (Validation.ValidationResult e -> Core.Term) +encodeValidationResult e = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.validation.validationResult")), + Core.applicationArgument = (Typed.unTypedTerm e)})) + -- | DSL constructor for hydra.validation.ValidationProfile validationProfile :: Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Validation.ValidationProfile validationProfile errorRules warningRules maxErrors maxWarnings = @@ -60,6 +78,10 @@ Core.projectionFieldName = (Core.Name "maxWarnings")})), Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.validation.ValidationProfile +validationProfileValidationProfile :: Typed.TypedName Validation.ValidationProfile +validationProfileValidationProfile = Typed.TypedName (Core.Name "hydra.validation.ValidationProfile") + -- | DSL accessor for the warningRules field of hydra.validation.ValidationProfile validationProfileWarningRules :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm (S.Set Core.Name) validationProfileWarningRules x = @@ -214,6 +236,10 @@ Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"), Core.projectionFieldName = (Core.Name "errors")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + +-- | DSL name token for hydra.validation.ValidationResult +validationResultValidationResult :: Typed.TypedName (Validation.ValidationResult e) +validationResultValidationResult = Typed.TypedName (Core.Name "hydra.validation.ValidationResult") -- | DSL accessor for the warnings field of hydra.validation.ValidationResult validationResultWarnings :: Typed.TypedTerm (Validation.ValidationResult e) -> Typed.TypedTerm [e] diff --git a/src/main/haskell/Hydra/Dsl/Variables.hs b/src/main/haskell/Hydra/Dsl/Variables.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Variables.hs @@ -0,0 +1,193 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | DSL functions for hydra.variables + +module Hydra.Dsl.Variables where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +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.Docs as DslDocs +import qualified Hydra.Dsl.Error.Checking as ErrorChecking +import qualified Hydra.Dsl.Error.Core as DslErrorCore +import qualified Hydra.Dsl.Error.File as DslErrorFile +import qualified Hydra.Dsl.Error.Packaging as DslErrorPackaging +import qualified Hydra.Dsl.Error.System as DslErrorSystem +import qualified Hydra.Dsl.Errors as DslErrors +import qualified Hydra.Dsl.File as DslFile +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.Query as DslQuery +import qualified Hydra.Dsl.Relational as DslRelational +import qualified Hydra.Dsl.Rewriting as DslRewriting +import qualified Hydra.Dsl.System as DslSystem +import qualified Hydra.Dsl.Tabular as DslTabular +import qualified Hydra.Dsl.Testing as DslTesting +import qualified Hydra.Dsl.Time as DslTime +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.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Names as Names +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variables as Variables +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | DSL reference to hydra.variables.freeTypeVariablesInTerm +freeTypeVariablesInTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm (S.Set Core.Name) +freeTypeVariablesInTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.freeTypeVariablesInTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.variables.freeVariablesInTerm +freeVariablesInTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm (S.Set Core.Name) +freeVariablesInTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.freeVariablesInTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.variables.freeVariablesInType +freeVariablesInType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm (S.Set Core.Name) +freeVariablesInType arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.freeVariablesInType")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.variables.freeVariablesInTypeOrdered +freeVariablesInTypeOrdered :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Core.Name] +freeVariablesInTypeOrdered arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.freeVariablesInTypeOrdered")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.variables.freeVariablesInTypeScheme +freeVariablesInTypeScheme :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm (S.Set Core.Name) +freeVariablesInTypeScheme arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.freeVariablesInTypeScheme")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.variables.freeVariablesInTypeSchemeSimple +freeVariablesInTypeSchemeSimple :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm (S.Set Core.Name) +freeVariablesInTypeSchemeSimple arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.freeVariablesInTypeSchemeSimple")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.variables.freeVariablesInTypeSimple +freeVariablesInTypeSimple :: Typed.TypedTerm Core.Type -> Typed.TypedTerm (S.Set Core.Name) +freeVariablesInTypeSimple arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.freeVariablesInTypeSimple")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.variables.isFreeVariableInTerm +isFreeVariableInTerm :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Bool +isFreeVariableInTerm arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.isFreeVariableInTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.variables.normalizeTypeVariablesInTerm +normalizeTypeVariablesInTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +normalizeTypeVariablesInTerm arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.normalizeTypeVariablesInTerm")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) + +-- | DSL reference to hydra.variables.replaceFreeTermVariable +replaceFreeTermVariable :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +replaceFreeTermVariable 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.variables.replaceFreeTermVariable")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.variables.replaceFreeTypeVariable +replaceFreeTypeVariable :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +replaceFreeTypeVariable 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.variables.replaceFreeTypeVariable")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.variables.substituteTypeVariables +substituteTypeVariables :: Typed.TypedTerm (M.Map Core.Name Core.Name) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type +substituteTypeVariables arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.substituteTypeVariables")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.variables.substituteVariable +substituteVariable :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +substituteVariable 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.variables.substituteVariable")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})), + Core.applicationArgument = (Typed.unTypedTerm arg2)})) + +-- | DSL reference to hydra.variables.substituteVariables +substituteVariables :: Typed.TypedTerm (M.Map Core.Name Core.Name) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +substituteVariables arg0 arg1 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.substituteVariables")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})), + Core.applicationArgument = (Typed.unTypedTerm arg1)})) + +-- | DSL reference to hydra.variables.unshadowVariables +unshadowVariables :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term +unshadowVariables arg0 = + Typed.TypedTerm (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.variables.unshadowVariables")), + Core.applicationArgument = (Typed.unTypedTerm arg0)})) diff --git a/src/main/haskell/Hydra/Dsl/Variants.hs b/src/main/haskell/Hydra/Dsl/Variants.hs --- a/src/main/haskell/Hydra/Dsl/Variants.hs +++ b/src/main/haskell/Hydra/Dsl/Variants.hs @@ -5,7 +5,9 @@ module Hydra.Dsl.Variants where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Variants as DecodeVariants import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Variants as EncodeVariants import qualified Hydra.Typed as Typed import qualified Hydra.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) @@ -56,6 +58,10 @@ Core.fieldName = (Core.Name "integer"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.variants.LiteralVariant +literalVariantLiteralVariant :: Typed.TypedName Variants.LiteralVariant +literalVariantLiteralVariant = Typed.TypedName (Core.Name "hydra.variants.LiteralVariant") + -- | DSL injection for the string variant of hydra.variants.LiteralVariant literalVariantString :: Typed.TypedTerm Variants.LiteralVariant literalVariantString = @@ -200,6 +206,10 @@ Core.fieldName = (Core.Name "set"), Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.variants.TermVariant +termVariantTermVariant :: Typed.TypedName Variants.TermVariant +termVariantTermVariant = Typed.TypedName (Core.Name "hydra.variants.TermVariant") + -- | DSL injection for the typeApplication variant of hydra.variants.TermVariant termVariantTypeApplication :: Typed.TypedTerm Variants.TermVariant termVariantTypeApplication = @@ -370,6 +380,10 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "set"), Core.fieldTerm = Core.TermUnit}})) + +-- | DSL name token for hydra.variants.TypeVariant +typeVariantTypeVariant :: Typed.TypedName Variants.TypeVariant +typeVariantTypeVariant = Typed.TypedName (Core.Name "hydra.variants.TypeVariant") -- | DSL injection for the union variant of hydra.variants.TypeVariant typeVariantUnion :: Typed.TypedTerm Variants.TypeVariant diff --git a/src/main/haskell/Hydra/Dsl/Yaml/Model.hs b/src/main/haskell/Hydra/Dsl/Yaml/Model.hs --- a/src/main/haskell/Hydra/Dsl/Yaml/Model.hs +++ b/src/main/haskell/Hydra/Dsl/Yaml/Model.hs @@ -5,7 +5,9 @@ module Hydra.Dsl.Yaml.Model where import qualified Hydra.Core as Core +import qualified Hydra.Decode.Yaml.Model as DecodeYamlModel import qualified Hydra.Dsl.Core as DslCore +import qualified Hydra.Encode.Yaml.Model as EncodeYamlModel import qualified Hydra.Typed as Typed import qualified Hydra.Yaml.Model as Model import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) @@ -21,6 +23,10 @@ Core.fieldName = (Core.Name "mapping"), Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.yaml.model.Node +nodeNode :: Typed.TypedName Model.Node +nodeNode = Typed.TypedName (Core.Name "hydra.yaml.model.Node") + -- | DSL injection for the scalar variant of hydra.yaml.model.Node nodeScalar :: Typed.TypedTerm Model.Scalar -> Typed.TypedTerm Model.Node nodeScalar x = @@ -83,6 +89,10 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "null"), Core.fieldTerm = Core.TermUnit}})) + +-- | DSL name token for hydra.yaml.model.Scalar +scalarScalar :: Typed.TypedName Model.Scalar +scalarScalar = Typed.TypedName (Core.Name "hydra.yaml.model.Scalar") -- | DSL injection for the str variant of hydra.yaml.model.Scalar scalarStr :: Typed.TypedTerm String -> Typed.TypedTerm Model.Scalar diff --git a/src/main/haskell/Hydra/Dsls.hs b/src/main/haskell/Hydra/Dsls.hs --- a/src/main/haskell/Hydra/Dsls.hs +++ b/src/main/haskell/Hydra/Dsls.hs @@ -75,37 +75,17 @@ -- | Generate a binding name for a DSL function from a type name dslBindingName :: Core.Name -> Core.Name -dslBindingName n = - - let parts = Strings.splitOn "." (Core.unName n) - localPart = Formatting.decapitalize (Names.localNameOf n) - localResult = Core.Name localPart - in (Optionals.cases (Lists.maybeInit parts) localResult (\nsParts -> Optionals.cases (Lists.uncons nsParts) localResult (\nsHeadTail -> - let dslNsParts = - Logic.ifElse (Equality.equal (Pairs.first nsHeadTail) "hydra") (Lists.concat2 [ - "hydra", - "dsl"] (Pairs.second nsHeadTail)) (Lists.concat2 [ - "hydra", - "dsl"] nsParts) - in (Core.Name (Strings.intercalate "." (Lists.concat2 dslNsParts [ - localPart])))))) +dslBindingName = + Names.derivedBindingName [ + "hydra", + "dsl"] False -- | Generate a qualified DSL element name from a type name and local element name dslDefinitionName :: Core.Name -> String -> Core.Name -dslDefinitionName typeName localName = - - let parts = Strings.splitOn "." (Core.unName typeName) - in (Optionals.cases (Lists.maybeInit parts) (Core.Name localName) (\nsParts -> - let dslNsParts = - Optionals.cases (Lists.uncons nsParts) [ - "hydra", - "dsl"] (\nsHeadTail -> Logic.ifElse (Equality.equal (Pairs.first nsHeadTail) "hydra") (Lists.concat2 [ - "hydra", - "dsl"] (Pairs.second nsHeadTail)) (Lists.concat2 [ - "hydra", - "dsl"] nsParts)) - in (Core.Name (Strings.intercalate "." (Lists.concat2 dslNsParts [ - localName]))))) +dslDefinitionName = + Names.derivedDefinitionName [ + "hydra", + "dsl"] False True -- | Transform a source module into a DSL module dslModule :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error (Maybe Packaging.Module) @@ -140,7 +120,13 @@ Packaging.moduleDependencyModule = ns, Packaging.moduleDependencyPackage = Nothing}) (Lists.nub (Lists.concat2 [ Packaging.moduleName mod, - (Packaging.ModuleName "hydra.typed")] (Lists.concat2 (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod)) (Lists.map dslModuleName (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod))))))), + (Packaging.ModuleName "hydra.typed"), + (Names.derivedModuleName [ + "hydra", + "encode"] True (Packaging.moduleName mod)), + (Names.derivedModuleName [ + "hydra", + "decode"] True (Packaging.moduleName mod))] (Lists.concat2 (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod)) (Lists.map dslModuleName (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod))))))), Packaging.moduleDefinitions = (Lists.map (\b -> Packaging.DefinitionTerm (Packaging.TermDefinition { Packaging.termDefinitionName = (Core.bindingName b), Packaging.termDefinitionMetadata = Nothing, @@ -149,16 +135,10 @@ -- | Generate a DSL module name from a source module name dslModuleName :: Packaging.ModuleName -> Packaging.ModuleName -dslModuleName ns = - - let parts = Strings.splitOn "." (Packaging.unModuleName ns) - prefixFull = - Packaging.ModuleName (Strings.cat [ - "hydra.dsl.", - (Packaging.unModuleName ns)]) - in (Optionals.cases (Lists.uncons parts) prefixFull (\ht -> Logic.ifElse (Equality.equal (Pairs.first ht) "hydra") (Packaging.ModuleName (Strings.cat [ - "hydra.dsl.", - (Strings.intercalate "." (Pairs.second ht))])) prefixFull)) +dslModuleName = + Names.derivedModuleName [ + "hydra", + "dsl"] False -- | Build a TypedTerm-wrapped TypeScheme (functions of phantom terms) from a TermSignature dslSignatureTypeScheme :: Typing.TermSignature -> Core.TypeScheme @@ -216,13 +196,185 @@ let typ = Strip.deannotateTypeParameters (Strip.deannotateType rawType) in (Right (case typ of Core.TypeRecord v0 -> Lists.concat [ - generateRecordConstructor rawType typeName v0, + [ + generateTypeNameToken rawType typeName], + (generateParametricRefBuilders rawType typeName), + (generateRecordConstructor rawType typeName v0), (Lists.map (generateRecordAccessor rawType typeName) v0), (Lists.map (generateRecordWithUpdater rawType typeName v0) v0)] - Core.TypeUnion v0 -> Lists.map (generateUnionInjector rawType typeName) v0 - Core.TypeWrap v0 -> generateWrappedTypeAccessors rawType typeName v0 + Core.TypeUnion v0 -> Lists.concat [ + [ + generateTypeNameToken rawType typeName], + (generateParametricRefBuilders rawType typeName), + (Lists.map (generateUnionInjector rawType typeName) v0)] + Core.TypeWrap v0 -> Lists.concat [ + [ + generateTypeNameToken rawType typeName], + (generateParametricRefBuilders rawType typeName), + (generateWrappedTypeAccessors rawType typeName v0)] _ -> [])))) +-- | Generate encode/decode composition builders for a parametric type definition +generateParametricRefBuilders :: Core.Type -> Core.Name -> [Core.Binding] +generateParametricRefBuilders origType typeName = + + let vars = collectForallVars origType + in (Logic.ifElse (Lists.null vars) [] [ + + let vars = collectForallVars origType + localName = Names.localNameOf typeName + builderLocalName = + Strings.cat [ + "encode", + localName] + builderName = dslDefinitionName typeName builderLocalName + refName = + Names.derivedBindingName [ + "hydra", + "encode"] True typeName + paramPairs = + Lists.map (\v -> ( + Core.unName v, + (Core.TypeApplication (Core.ApplicationType { + Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")), + Core.applicationTypeArgument = (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable v), + Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))})))) vars + appBody = + Lists.foldl (\acc -> \pp -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.core.Term"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "application"), + Core.fieldTerm = (Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.core.Application"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "function"), + Core.fieldTerm = acc}, + Core.Field { + Core.fieldName = (Core.Name "argument"), + Core.fieldTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")), + Core.applicationArgument = (Core.TermVariable (Core.Name (Pairs.first pp)))}))}]}))}})) (Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.core.Term"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "variable"), + Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName refName)))}))}})) paramPairs + builderTerm = + Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"), + Core.wrappedTermBody = appBody}) + rawBody = + Lists.foldl (\acc -> \pp -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name (Pairs.first pp)), + Core.lambdaDomain = (Just (Pairs.second pp)), + Core.lambdaBody = acc})) builderTerm (Lists.reverse paramPairs) + description = + Strings.cat [ + "DSL composition builder for the ", + "encode", + "r of ", + (Core.unName typeName)] + body = Annotations.setTermDescription (Just description) rawBody + resultType = nominalResultType typeName origType + paramTypes = + Lists.map (\v -> Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable v), + Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})) vars + ts = + dslTypeScheme origType paramTypes (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = resultType, + Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})) + in Core.Binding { + Core.bindingName = builderName, + Core.bindingTerm = body, + Core.bindingTypeScheme = (Just ts)}, + + let vars = collectForallVars origType + localName = Names.localNameOf typeName + builderLocalName = + Strings.cat [ + "decode", + localName] + builderName = dslDefinitionName typeName builderLocalName + refName = + Names.derivedBindingName [ + "hydra", + "decode"] True typeName + paramPairs = + Lists.map (\v -> ( + Core.unName v, + (Core.TypeApplication (Core.ApplicationType { + Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")), + Core.applicationTypeArgument = (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), + Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), + Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeVariable v)}))}))}))})))) vars + appBody = + Lists.foldl (\acc -> \pp -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.core.Term"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "application"), + Core.fieldTerm = (Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.core.Application"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "function"), + Core.fieldTerm = acc}, + Core.Field { + Core.fieldName = (Core.Name "argument"), + Core.fieldTerm = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")), + Core.applicationArgument = (Core.TermVariable (Core.Name (Pairs.first pp)))}))}]}))}})) (Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.core.Term"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "variable"), + Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName refName)))}))}})) paramPairs + builderTerm = + Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"), + Core.wrappedTermBody = appBody}) + rawBody = + Lists.foldl (\acc -> \pp -> Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name (Pairs.first pp)), + Core.lambdaDomain = (Just (Pairs.second pp)), + Core.lambdaBody = acc})) builderTerm (Lists.reverse paramPairs) + description = + Strings.cat [ + "DSL composition builder for the ", + "decode", + "r of ", + (Core.unName typeName)] + body = Annotations.setTermDescription (Just description) rawBody + resultType = nominalResultType typeName origType + paramTypes = + Lists.map (\v -> Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), + Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), + Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = (Core.TypeVariable v)}))}))})) vars + ts = + dslTypeScheme origType paramTypes (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), + Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { + Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), + Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { + Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), + Core.eitherTypeRight = resultType}))}))})) + in Core.Binding { + Core.bindingName = builderName, + Core.bindingTerm = body, + Core.bindingTypeScheme = (Just ts)}]) + -- | Generate a record field accessor function generateRecordAccessor :: Core.Type -> Core.Name -> Core.FieldType -> Core.Binding generateRecordAccessor origType typeName ft = @@ -514,6 +666,38 @@ ts = dslSignatureTypeScheme sig in Core.Binding { Core.bindingName = (dslDefinitionName refName (Names.localNameOf refName)), + Core.bindingTerm = body, + Core.bindingTypeScheme = (Just ts)} + +-- | Generate a TypedName token constant for a type definition +generateTypeNameToken :: Core.Type -> Core.Name -> Core.Binding +generateTypeNameToken origType typeName = + + let localName = Names.localNameOf typeName + tokenLocalName = + Strings.cat [ + Formatting.decapitalize localName, + localName] + tokenName = dslDefinitionName typeName tokenLocalName + description = + Strings.cat [ + "DSL name token for ", + (Core.unName typeName)] + body = + Annotations.setTermDescription (Just description) (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedName"), + Core.wrappedTermBody = (Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), + Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))})) + ts = + Core.TypeScheme { + Core.typeSchemeVariables = (collectForallVars origType), + Core.typeSchemeBody = (Core.TypeApplication (Core.ApplicationType { + Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedName")), + Core.applicationTypeArgument = (nominalResultType typeName origType)})), + Core.typeSchemeConstraints = Nothing} + in Core.Binding { + Core.bindingName = tokenName, Core.bindingTerm = body, Core.bindingTypeScheme = (Just ts)} diff --git a/src/main/haskell/Hydra/Encode/Error/Packaging.hs b/src/main/haskell/Hydra/Encode/Error/Packaging.hs --- a/src/main/haskell/Hydra/Encode/Error/Packaging.hs +++ b/src/main/haskell/Hydra/Encode/Error/Packaging.hs @@ -186,6 +186,11 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "invalidPackageName"), Core.fieldTerm = (invalidPackageNameError v0)}}) + ErrorPackaging.InvalidPackageErrorUndeclaredDependency v0 -> Core.TermInject (Core.Injection { + Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), + Core.injectionField = Core.Field { + Core.fieldName = (Core.Name "undeclaredDependency"), + Core.fieldTerm = (undeclaredDependencyError v0)}}) -- | Encoder for hydra.error.packaging.InvalidPackageNameError invalidPackageNameError :: ErrorPackaging.InvalidPackageNameError -> Core.Term @@ -209,3 +214,19 @@ Core.Field { Core.fieldName = (Core.Name "name"), Core.fieldTerm = (EncodeCore.name (ErrorPackaging.missingDocumentationErrorName x))}]}) + +-- | Encoder for hydra.error.packaging.UndeclaredDependencyError +undeclaredDependencyError :: ErrorPackaging.UndeclaredDependencyError -> Core.Term +undeclaredDependencyError x = + Core.TermRecord (Core.Record { + Core.recordTypeName = (Core.Name "hydra.error.packaging.UndeclaredDependencyError"), + Core.recordFields = [ + Core.Field { + Core.fieldName = (Core.Name "moduleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.undeclaredDependencyErrorModuleName x))}, + Core.Field { + Core.fieldName = (Core.Name "referencedName"), + Core.fieldTerm = (EncodeCore.name (ErrorPackaging.undeclaredDependencyErrorReferencedName x))}, + Core.Field { + Core.fieldName = (Core.Name "owningModuleName"), + Core.fieldTerm = (EncodePackaging.moduleName (ErrorPackaging.undeclaredDependencyErrorOwningModuleName x))}]}) diff --git a/src/main/haskell/Hydra/Encode/Typed.hs b/src/main/haskell/Hydra/Encode/Typed.hs --- a/src/main/haskell/Hydra/Encode/Typed.hs +++ b/src/main/haskell/Hydra/Encode/Typed.hs @@ -23,6 +23,13 @@ Core.fieldName = (Core.Name "term"), Core.fieldTerm = (typedTerm a (Typed.typedBindingTerm x))}]}) +-- | Encoder for hydra.typed.TypedName +typedName :: (a -> Core.Term) -> Typed.TypedName a -> Core.Term +typedName a x = + Core.TermWrap (Core.WrappedTerm { + Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedName"), + Core.wrappedTermBody = (EncodeCore.name (Typed.unTypedName x))}) + -- | Encoder for hydra.typed.TypedTerm typedTerm :: (a -> Core.Term) -> Typed.TypedTerm a -> Core.Term typedTerm a x = diff --git a/src/main/haskell/Hydra/Encoding.hs b/src/main/haskell/Hydra/Encoding.hs --- a/src/main/haskell/Hydra/Encoding.hs +++ b/src/main/haskell/Hydra/Encoding.hs @@ -27,7 +27,6 @@ import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Names as Names import qualified Hydra.Packaging as Packaging @@ -67,17 +66,10 @@ -- | Generate a binding name for an encoder function from a type name encodeBindingName :: Core.Name -> Core.Name -encodeBindingName n = - - let parts = Strings.splitOn "." (Core.unName n) - localPart = Formatting.decapitalize (Names.localNameOf n) - localResult = Core.Name localPart - in (Optionals.cases (Lists.maybeInit parts) localResult (\nsParts -> Optionals.cases (Lists.uncons nsParts) localResult (\nsUc -> - let tail = Pairs.second nsUc - in (Core.Name (Strings.intercalate "." (Lists.concat2 [ - "hydra", - "encode"] (Lists.concat2 tail [ - localPart]))))))) +encodeBindingName = + Names.derivedBindingName [ + "hydra", + "encode"] True -- | Generate an encoder for an Either type encodeEitherType :: Core.EitherType -> Core.Term @@ -349,13 +341,10 @@ -- | Generate an encoder module name from a source module name encodeModuleName :: Packaging.ModuleName -> Packaging.ModuleName -encodeModuleName ns = - - let parts = Strings.splitOn "." (Packaging.unModuleName ns) - fallback = Packaging.ModuleName (Packaging.unModuleName ns) - in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.cat [ - "hydra.encode.", - (Strings.intercalate "." (Pairs.second uc))]))) +encodeModuleName = + Names.derivedModuleName [ + "hydra", + "encode"] True -- | Encode a Name as a term encodeName :: Core.Name -> Core.Term diff --git a/src/main/haskell/Hydra/Error/Packaging.hs b/src/main/haskell/Hydra/Error/Packaging.hs --- a/src/main/haskell/Hydra/Error/Packaging.hs +++ b/src/main/haskell/Hydra/Error/Packaging.hs @@ -181,7 +181,9 @@ -- | A module within the package is invalid InvalidPackageErrorInvalidModule InvalidModuleError | -- | A package whose name does not match the package-name naming convention - InvalidPackageErrorInvalidPackageName InvalidPackageNameError + InvalidPackageErrorInvalidPackageName InvalidPackageNameError | + -- | A module references a name owned by another module that is not among its declared dependencies + InvalidPackageErrorUndeclaredDependency UndeclaredDependencyError deriving (Eq, Ord, Read, Show) _InvalidPackageError = Core.Name "hydra.error.packaging.InvalidPackageError" @@ -194,6 +196,8 @@ _InvalidPackageError_invalidPackageName = Core.Name "invalidPackageName" +_InvalidPackageError_undeclaredDependency = Core.Name "undeclaredDependency" + -- | A package whose name does not match the hyphen-separated lowercase naming convention. Package names must be hyphen-separated lowercase segments, each starting with a letter, e.g. hydra-kernel or hydra-python. data InvalidPackageNameError = InvalidPackageNameError { @@ -219,3 +223,22 @@ _MissingDocumentationError_moduleName = Core.Name "moduleName" _MissingDocumentationError_name = Core.Name "name" + +-- | A module references a name owned by another module which is not among its declared moduleDependencies. Like a missing import: the reference may still resolve today via another module's transitive dependencies, but the declared dependency list no longer reflects what the module actually uses, and inference-time resolution is not guaranteed. +data UndeclaredDependencyError = + UndeclaredDependencyError { + -- | The name of the module containing the undeclared reference + undeclaredDependencyErrorModuleName :: Packaging.ModuleName, + -- | The free name referenced by the module's definitions + undeclaredDependencyErrorReferencedName :: Core.Name, + -- | The name of the module that actually defines the referenced name + undeclaredDependencyErrorOwningModuleName :: Packaging.ModuleName} + deriving (Eq, Ord, Read, Show) + +_UndeclaredDependencyError = Core.Name "hydra.error.packaging.UndeclaredDependencyError" + +_UndeclaredDependencyError_moduleName = Core.Name "moduleName" + +_UndeclaredDependencyError_referencedName = Core.Name "referencedName" + +_UndeclaredDependencyError_owningModuleName = Core.Name "owningModuleName" diff --git a/src/main/haskell/Hydra/Extract/Core.hs b/src/main/haskell/Hydra/Extract/Core.hs --- a/src/main/haskell/Hydra/Extract/Core.hs +++ b/src/main/haskell/Hydra/Extract/Core.hs @@ -92,18 +92,6 @@ Errors.unexpectedShapeErrorExpected = "boolean", Errors.unexpectedShapeErrorActual = (ShowCore.literal v)}))) --- | Extract a specific case handler from a case statement term -caseField :: Core.Name -> String -> Graph.Graph -> Core.Term -> Either Errors.Error Core.CaseAlternative -caseField name n graph term = - - let fieldName = Core.Name n - in (Eithers.bind (cases name graph term) (\cs -> - let matching = - Lists.find (\f -> Equality.equal (Core.unName (Core.caseAlternativeName f)) (Core.unName fieldName)) (Core.caseStatementCases cs) - in (Optionals.cases matching (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError { - Errors.unexpectedShapeErrorExpected = "matching case", - Errors.unexpectedShapeErrorActual = "no matching case"})))) (\mf -> Right mf)))) - -- | Extract case statement from a term cases :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error Core.CaseStatement cases name graph term0 = @@ -177,13 +165,6 @@ Core.TermUnit -> Right () _ -> Left (Errors.DecodingError "expected a unit value")) --- | Decode a wrapped value using the provided body decoder -decodeWrapped :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError t0 -decodeWrapped bodyDecoder g term = - Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of - Core.TermWrap v0 -> bodyDecoder g (Core.wrappedTermBody v0) - _ -> Left (Errors.DecodingError "expected wrapped value")) - -- | Extract an either value from a term, applying functions to the left and right values eitherTerm :: (Core.Term -> Either Errors.Error t0) -> (Core.Term -> Either Errors.Error t1) -> Graph.Graph -> Core.Term -> Either Errors.Error (Either t0 t1) eitherTerm leftFun rightFun graph term0 = @@ -387,13 +368,6 @@ _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError { Errors.unexpectedShapeErrorExpected = "list", Errors.unexpectedShapeErrorActual = (ShowCore.term stripped)})))) - --- | Extract the first element of a list term -listHead :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Term -listHead graph term = - Eithers.bind (list graph term) (\l -> Optionals.cases (Lists.maybeHead l) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError { - Errors.unexpectedShapeErrorExpected = "non-empty list", - Errors.unexpectedShapeErrorActual = "empty list"})))) (\h -> Right h)) -- | Extract a list of values from a term, mapping a function over each element listOf :: (Core.Term -> Either Errors.Error t0) -> Graph.Graph -> Core.Term -> Either Errors.Error [t0] diff --git a/src/main/haskell/Hydra/Extract/Json.hs b/src/main/haskell/Hydra/Extract/Json.hs --- a/src/main/haskell/Hydra/Extract/Json.hs +++ b/src/main/haskell/Hydra/Extract/Json.hs @@ -17,6 +17,7 @@ import qualified Hydra.File as File import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model +import qualified Hydra.Json.Writer as Writer import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals @@ -81,25 +82,25 @@ optString fname m = Optionals.cases (opt fname m) (Right Nothing) (\s -> Eithers.map (\x -> Just x) (expectString s)) -- | Look up a required field in a JSON object, failing if not found -require :: Ord t0 => (t0 -> M.Map t0 t1 -> Either String t1) +require :: String -> M.Map String t0 -> Either String t0 require fname m = Optionals.cases (Maps.lookup fname m) (Left (Strings.cat [ "required attribute ", - (showValue fname), + (showValue (Model.ValueString fname)), " not found"])) (\value -> Right value) -- | Look up a required array field in a JSON object -requireArray :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String [Model.Value]) +requireArray :: String -> M.Map String Model.Value -> Either String [Model.Value] requireArray fname m = Eithers.bind (require fname m) expectArray -- | Look up a required number field in a JSON object -requireNumber :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String Sci.Scientific) +requireNumber :: String -> M.Map String Model.Value -> Either String Sci.Scientific requireNumber fname m = Eithers.bind (require fname m) expectNumber -- | Look up a required string field in a JSON object -requireString :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String String) +requireString :: String -> M.Map String Model.Value -> Either String String requireString fname m = Eithers.bind (require fname m) expectString --- | Show a JSON value as a string (placeholder implementation) -showValue :: t0 -> String -showValue value = "TODO: implement showValue" +-- | Show a JSON value as a string +showValue :: Model.Value -> String +showValue value = Writer.printJson value diff --git a/src/main/haskell/Hydra/Json/Decode.hs b/src/main/haskell/Hydra/Json/Decode.hs --- a/src/main/haskell/Hydra/Json/Decode.hs +++ b/src/main/haskell/Hydra/Json/Decode.hs @@ -35,6 +35,7 @@ import qualified Hydra.Relational as Relational import qualified Hydra.Show.Core as ShowCore import qualified Hydra.Strip as Strip +import qualified Hydra.Substitution as Substitution import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing @@ -167,7 +168,28 @@ fromJson types tname typ value = let stripped = Strip.deannotateType typ + reduceApp = + \app -> + let fn = Strip.deannotateType (Core.applicationTypeFunction app) + arg = Core.applicationTypeArgument app + in case fn of + Core.TypeApplication v0 -> Eithers.either (\err -> Left err) (\reducedFn -> reduceApp (Core.ApplicationType { + Core.applicationTypeFunction = reducedFn, + Core.applicationTypeArgument = arg})) (reduceApp v0) + Core.TypeForall v0 -> Right (Substitution.substInType (Substitution.singletonTypeSubst (Core.forallTypeParameter v0) arg) (Core.forallTypeBody v0)) + Core.TypeVariable v0 -> + let lookedUp = Maps.lookup v0 types + in (Optionals.cases lookedUp (Left (Strings.cat [ + "unknown type variable: ", + (Core.unName v0)])) (\resolvedFn -> reduceApp (Core.ApplicationType { + Core.applicationTypeFunction = resolvedFn, + Core.applicationTypeArgument = arg}))) + _ -> Left (Strings.cat [ + "cannot apply a non-parametric type: ", + (ShowCore.type_ fn)]) in case stripped of + Core.TypeApplication v0 -> Eithers.either (\err -> Left err) (\reducedType -> fromJson types tname reducedType value) (reduceApp v0) + Core.TypeForall v0 -> fromJson types tname (Core.forallTypeBody v0) value Core.TypeLiteral v0 -> decodeLiteral v0 value Core.TypeList v0 -> let decodeElem = \v -> fromJson types tname v0 v diff --git a/src/main/haskell/Hydra/Json/Encode.hs b/src/main/haskell/Hydra/Json/Encode.hs --- a/src/main/haskell/Hydra/Json/Encode.hs +++ b/src/main/haskell/Hydra/Json/Encode.hs @@ -36,6 +36,7 @@ import qualified Hydra.Relational as Relational import qualified Hydra.Show.Core as ShowCore import qualified Hydra.Strip as Strip +import qualified Hydra.Substitution as Substitution import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing @@ -97,7 +98,28 @@ let stripped = Strip.deannotateType typ strippedTerm = Strip.deannotateTerm term + reduceApp = + \app -> + let fn = Strip.deannotateType (Core.applicationTypeFunction app) + arg = Core.applicationTypeArgument app + in case fn of + Core.TypeApplication v0 -> Eithers.either (\err -> Left err) (\reducedFn -> reduceApp (Core.ApplicationType { + Core.applicationTypeFunction = reducedFn, + Core.applicationTypeArgument = arg})) (reduceApp v0) + Core.TypeForall v0 -> Right (Substitution.substInType (Substitution.singletonTypeSubst (Core.forallTypeParameter v0) arg) (Core.forallTypeBody v0)) + Core.TypeVariable v0 -> + let lookedUp = Maps.lookup v0 types + in (Optionals.cases lookedUp (Left (Strings.cat [ + "unknown type variable: ", + (Core.unName v0)])) (\resolvedFn -> reduceApp (Core.ApplicationType { + Core.applicationTypeFunction = resolvedFn, + Core.applicationTypeArgument = arg}))) + _ -> Left (Strings.cat [ + "cannot apply a non-parametric type: ", + (ShowCore.type_ fn)]) in case stripped of + Core.TypeApplication v0 -> Eithers.either (\err -> Left err) (\reducedType -> toJson types tname reducedType term) (reduceApp v0) + Core.TypeForall v0 -> toJson types tname (Core.forallTypeBody v0) term Core.TypeLiteral _ -> case strippedTerm of Core.TermLiteral v1 -> encodeLiteral v1 _ -> Left "expected literal term" diff --git a/src/main/haskell/Hydra/Lib/Defaults.hs b/src/main/haskell/Hydra/Lib/Defaults.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Defaults.hs @@ -0,0 +1,1315 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | A module which provides a single map from primitive names to their default, cross-compilable reference implementations, for primitives which declare one. + +module Hydra.Lib.Defaults where + +import qualified Hydra.Core as Core +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M + +-- | A map from primitive name to default (cross-compilable) reference implementation, for primitives which declare one. Each value is an encoded (reified) term; decode it to recover the executable implementation. +defaultImplementations :: M.Map Core.Name Core.Term +defaultImplementations = + M.fromList [ + ( + Core.Name "hydra.lib.eithers.bimap", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "g"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermEither (Left (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "y"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermEither (Right (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "g")), + Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))}))), + ( + Core.Name "hydra.lib.eithers.bind", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "x"))))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))), + ( + Core.Name "hydra.lib.eithers.foldl", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc0"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "el"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "a"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "el"))}))}))}))}))}))})), + Core.applicationArgument = (Core.TermEither (Right (Core.TermVariable (Core.Name "acc0"))))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))}))), + ( + Core.Name "hydra.lib.eithers.fromLeft", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "def"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermVariable (Core.Name "def"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))), + ( + Core.Name "hydra.lib.eithers.fromRight", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "def"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermVariable (Core.Name "def"))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))), + ( + Core.Name "hydra.lib.eithers.isLeft", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean True))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean False))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))), + ( + Core.Name "hydra.lib.eithers.isRight", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean False))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean True))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))), + ( + Core.Name "hydra.lib.eithers.lefts", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "l"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "l"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))})), + Core.applicationArgument = (Core.TermList [])})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))), + ( + Core.Name "hydra.lib.eithers.map", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "x"))))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "y"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermEither (Right (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))), + ( + Core.Name "hydra.lib.eithers.mapList", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "y"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "ys"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "ys"))}))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))}))}))})), + Core.applicationArgument = (Core.TermEither (Right (Core.TermList [])))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))), + ( + Core.Name "hydra.lib.eithers.mapOptional", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})), + Core.applicationArgument = (Core.TermEither (Right (Core.TermOptional Nothing)))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "y"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermOptional (Just (Core.TermVariable (Core.Name "y"))))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}))}))}))}))), + ( + Core.Name "hydra.lib.eithers.mapSet", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "ys"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.fromList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "ys"))}))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "y"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "ys"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "ys"))}))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))}))}))})), + Core.applicationArgument = (Core.TermEither (Right (Core.TermList [])))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))}))}))), + ( + Core.Name "hydra.lib.eithers.partitionEithers", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "l"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "l"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "r"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "r"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))})), + Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))), + ( + Core.Name "hydra.lib.eithers.rights", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "e"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "r"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "r"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))})), + Core.applicationArgument = (Core.TermList [])})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))), + ( + Core.Name "hydra.lib.equality.identity", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))), + ( + Core.Name "hydra.lib.equality.max", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "y"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.gte")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))}))), + ( + Core.Name "hydra.lib.equality.min", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "y"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.lte")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))}))), + ( + Core.Name "hydra.lib.lists.bind", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.concat2")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermList [])})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))), + ( + Core.Name "hydra.lib.lists.dropWhile", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.span")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))}))), + ( + Core.Name "hydra.lib.lists.filter", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermList [])})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))), + ( + Core.Name "hydra.lib.lists.find", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermOptional (Just (Core.TermVariable (Core.Name "x"))))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermOptional Nothing)})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))), + ( + Core.Name "hydra.lib.lists.partition", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))})), + Core.applicationArgument = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))))}))}))}))})), + Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))), + ( + Core.Name "hydra.lib.lists.span", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.and")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.null")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))})), + Core.applicationArgument = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.concat2")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermList [ + Core.TermVariable (Core.Name "x")])}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))})), + Core.applicationArgument = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.concat2")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermList [ + Core.TermVariable (Core.Name "x")])}))))}))}))}))})), + Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))), + ( + Core.Name "hydra.lib.logic.and", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "a"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "b"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "b"))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))}))}))}))), + ( + Core.Name "hydra.lib.logic.not", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "a"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))}))}))), + ( + Core.Name "hydra.lib.logic.or", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "a"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "b"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "b"))}))}))}))), + ( + Core.Name "hydra.lib.maps.alter", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "k"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), + Core.applicationArgument = (Core.TermVariable (Core.Name "k"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.delete")), + Core.applicationArgument = (Core.TermVariable (Core.Name "k"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "vNew"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.insert")), + Core.applicationArgument = (Core.TermVariable (Core.Name "k"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "vNew"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))}))), + ( + Core.Name "hydra.lib.maps.bimap", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "fk"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "fv"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "fk")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "fv")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}))))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))}))), + ( + Core.Name "hydra.lib.maps.filter", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.filter")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "pr"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "pr"))}))}))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))), + ( + Core.Name "hydra.lib.maps.filterWithKey", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.filter")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "pr"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "pr"))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "pr"))}))}))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))), + ( + Core.Name "hydra.lib.maps.findWithDefault", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "def"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "k"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.fromOptional")), + Core.applicationArgument = (Core.TermVariable (Core.Name "def"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")), + Core.applicationArgument = (Core.TermVariable (Core.Name "k"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))), + ( + Core.Name "hydra.lib.maps.map", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}))))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))), + ( + Core.Name "hydra.lib.maps.mapKeys", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))), + ( + Core.Name "hydra.lib.math.even", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.equal")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.fromOptional")), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 0)))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.maybeMod")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 2)))}))}))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 0)))}))}))), + ( + Core.Name "hydra.lib.math.odd", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.not")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.even")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}))), + ( + Core.Name "hydra.lib.optionals.apply", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "mf"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "mx"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.bind")), + Core.applicationArgument = (Core.TermVariable (Core.Name "mf"))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "mx"))}))}))}))}))}))), + ( + Core.Name "hydra.lib.optionals.bind", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})), + Core.applicationArgument = (Core.TermOptional Nothing)})), + Core.applicationArgument = (Core.TermVariable (Core.Name "f"))}))}))}))), + ( + Core.Name "hydra.lib.optionals.cat", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "v"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), + Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))}))}))})), + Core.applicationArgument = (Core.TermList [])})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))), + ( + Core.Name "hydra.lib.optionals.compose", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "g"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.bind")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "g"))}))}))}))}))), + ( + Core.Name "hydra.lib.optionals.fromOptional", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "def"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "def"))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))}))}))}))), + ( + Core.Name "hydra.lib.optionals.isGiven", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean True))}))}))}))), + ( + Core.Name "hydra.lib.optionals.isNone", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})), + Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "_"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean False))}))}))}))), + ( + Core.Name "hydra.lib.optionals.map", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})), + Core.applicationArgument = (Core.TermOptional Nothing)})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermOptional (Just (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))))}))}))}))}))), + ( + Core.Name "hydra.lib.optionals.mapOptional", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "xs"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cat")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), + Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))}))), + ( + Core.Name "hydra.lib.optionals.pure", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermOptional (Just (Core.TermVariable (Core.Name "x"))))}))), + ( + Core.Name "hydra.lib.optionals.toList", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "m"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")), + Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})), + Core.applicationArgument = (Core.TermList [])})), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "x"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermList [ + Core.TermVariable (Core.Name "x")])}))}))}))), + ( + Core.Name "hydra.lib.pairs.bimap", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "g"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "p"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermPair ( + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "f")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}), + (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "g")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}))))}))}))}))), + ( + Core.Name "hydra.lib.sets.difference", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s1"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s2"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "el"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.member")), + Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "s2"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.insert")), + Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.lib.sets.empty"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "s1"))}))}))}))}))), + ( + Core.Name "hydra.lib.sets.intersection", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s1"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s2"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "el"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.member")), + Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "s2"))}))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.insert")), + Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.lib.sets.empty"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "s1"))}))}))}))}))), + ( + Core.Name "hydra.lib.sets.map", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "f"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.fromList")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")), + Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))}))}))), + ( + Core.Name "hydra.lib.sets.union", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s1"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s2"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "el"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.insert")), + Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "s2"))})), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")), + Core.applicationArgument = (Core.TermVariable (Core.Name "s1"))}))}))}))}))), + ( + Core.Name "hydra.lib.sets.unions", + (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "ss"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")), + Core.applicationArgument = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermLambda (Core.Lambda { + Core.lambdaParameter = (Core.Name "s"), + Core.lambdaDomain = Nothing, + Core.lambdaBody = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.union")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.lib.sets.empty"))})), + Core.applicationArgument = (Core.TermVariable (Core.Name "ss"))}))})))] diff --git a/src/main/haskell/Hydra/Lib/Hashing.hs b/src/main/haskell/Hydra/Lib/Hashing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Hashing.hs @@ -0,0 +1,88 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Primitives in the hydra.lib.hashing module. + +module Hydra.Lib.Hashing where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +import qualified Hydra.Error.Checking as Checking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci + +sha256 :: Packaging.PrimitiveDefinition +sha256 = + Packaging.PrimitiveDefinition { + Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.hashing.sha256"), + Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata { + Packaging.entityMetadataDescription = (Just "Compute the SHA-256 digest of a sequence of bytes."), + Packaging.entityMetadataComments = [ + "sha256(bytes) returns the 32-byte SHA-256 digest of bytes. Total: hashing is pure and never fails.", + "Pairs with hydra.lib.files.readFile, which returns raw bytes, to hash file contents."], + Packaging.entityMetadataSeeAlso = [], + Packaging.entityMetadataLifecycle = Nothing})), + Packaging.primitiveDefinitionSignature = Typing.TermSignature { + Typing.termSignatureTypeParameters = [], + Typing.termSignatureParameters = [ + Typing.Parameter { + Typing.parameterName = (Core.Name "arg0"), + Typing.parameterDescription = Nothing, + Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBinary), + Typing.parameterIsLazy = False}], + Typing.termSignatureResult = Typing.Result { + Typing.resultDescription = Nothing, + Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBinary)}}, + Packaging.primitiveDefinitionIsPure = True, + Packaging.primitiveDefinitionIsTotal = True, + Packaging.primitiveDefinitionDefaultImplementation = Nothing} + +sha256Hex :: Packaging.PrimitiveDefinition +sha256Hex = + Packaging.PrimitiveDefinition { + Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.hashing.sha256Hex"), + Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata { + Packaging.entityMetadataDescription = (Just "Compute the SHA-256 digest of a sequence of bytes as a lowercase hex string."), + Packaging.entityMetadataComments = [ + "sha256Hex(bytes) returns the SHA-256 digest of bytes as a 64-character lowercase hexadecimal string. Equivalent to hex-encoding the output of sha256. Total: hashing is pure and never fails.", + "Pairs with hydra.lib.files.readFile, which returns raw bytes, to hash file contents."], + Packaging.entityMetadataSeeAlso = [], + Packaging.entityMetadataLifecycle = Nothing})), + Packaging.primitiveDefinitionSignature = Typing.TermSignature { + Typing.termSignatureTypeParameters = [], + Typing.termSignatureParameters = [ + Typing.Parameter { + Typing.parameterName = (Core.Name "arg0"), + Typing.parameterDescription = Nothing, + Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBinary), + Typing.parameterIsLazy = False}], + Typing.termSignatureResult = Typing.Result { + Typing.resultDescription = Nothing, + Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}}, + Packaging.primitiveDefinitionIsPure = True, + Packaging.primitiveDefinitionIsTotal = True, + Packaging.primitiveDefinitionDefaultImplementation = Nothing} diff --git a/src/main/haskell/Hydra/Lib/Lists.hs b/src/main/haskell/Hydra/Lib/Lists.hs --- a/src/main/haskell/Hydra/Lib/Lists.hs +++ b/src/main/haskell/Hydra/Lib/Lists.hs @@ -1275,12 +1275,12 @@ Core.lambdaBody = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")), + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")), Core.applicationArgument = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), + Core.lambdaParameter = (Core.Name "acc"), Core.lambdaDomain = Nothing, Core.lambdaBody = (Core.TermLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "acc"), + Core.lambdaParameter = (Core.Name "x"), Core.lambdaDomain = Nothing, Core.lambdaBody = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { @@ -1290,33 +1290,37 @@ Core.applicationFunction = (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.and")), Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "p")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})), + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.null")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))})), Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.null")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})), + Core.applicationFunction = (Core.TermVariable (Core.Name "p")), + Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))})), Core.applicationArgument = (Core.TermPair ( Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}), + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.concat2")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermList [ + Core.TermVariable (Core.Name "x")])}), (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))})), Core.applicationArgument = (Core.TermPair ( - Core.TermList [], + Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}), (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))))}))}))}))})), + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.concat2")), + Core.applicationArgument = (Core.TermApplication (Core.Application { + Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")), + Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), + Core.applicationArgument = (Core.TermList [ + Core.TermVariable (Core.Name "x")])}))))}))}))}))})), Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})), Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})))} diff --git a/src/main/haskell/Hydra/Names.hs b/src/main/haskell/Hydra/Names.hs --- a/src/main/haskell/Hydra/Names.hs +++ b/src/main/haskell/Hydra/Names.hs @@ -72,6 +72,33 @@ ":", local]))) +-- | Generate a binding name for a derived function from a type/term name, given the category's namespace segments +derivedBindingName :: [String] -> Bool -> Core.Name -> Core.Name +derivedBindingName categoryPrefix alwaysDropFirst n = + derivedDefinitionName categoryPrefix alwaysDropFirst False n (Formatting.decapitalize (localNameOf n)) + +-- | Generate a derived element name from a source name's namespace and an explicit local name +derivedDefinitionName :: [String] -> Bool -> Bool -> Core.Name -> String -> Core.Name +derivedDefinitionName categoryPrefix alwaysDropFirst prefixWhenNoNamespace n localName = + + let localResult = Core.Name localName + prefixedResult = Core.Name (Strings.intercalate "." (Lists.concat2 categoryPrefix [ + localName])) + noNamespaceResult = Logic.ifElse prefixWhenNoNamespace prefixedResult localResult + in (Optionals.cases (Lists.maybeInit (Strings.splitOn "." (Core.unName n))) noNamespaceResult (\nsParts -> Optionals.cases (Lists.uncons nsParts) noNamespaceResult (\nsHeadTail -> + let categoryPrefixResolved = + Logic.ifElse (Logic.or alwaysDropFirst (Equality.equal (Pairs.first nsHeadTail) "hydra")) (Lists.concat2 categoryPrefix (Pairs.second nsHeadTail)) (Lists.concat2 categoryPrefix nsParts) + in (Core.Name (Strings.intercalate "." (Lists.concat2 categoryPrefixResolved [ + localName])))))) + +-- | Generate a derived module name from a source module name, given the category's namespace segments +derivedModuleName :: [String] -> Bool -> Packaging.ModuleName -> Packaging.ModuleName +derivedModuleName categoryPrefix alwaysDropFirst ns = + + let parts = Strings.splitOn "." (Packaging.unModuleName ns) + fallback = Packaging.ModuleName (Strings.intercalate "." (Lists.concat2 categoryPrefix parts)) + in (Optionals.cases (Lists.uncons parts) fallback (\ht -> Logic.ifElse (Logic.or alwaysDropFirst (Equality.equal (Pairs.first ht) "hydra")) (Packaging.ModuleName (Strings.intercalate "." (Lists.concat2 categoryPrefix (Pairs.second ht)))) fallback)) + -- | Generate a fresh type variable name, threading InferenceContext freshName :: Typing.InferenceContext -> (Core.Name, Typing.InferenceContext) freshName cx = diff --git a/src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Testing.hs b/src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Testing.hs --- a/src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Testing.hs +++ b/src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Testing.hs @@ -28,6 +28,7 @@ import qualified Hydra.Overlay.Haskell.Dsl.Typed.Terms as MetaTerms import Hydra.Overlay.Haskell.Dsl.Terms (ToPrimName) import qualified Hydra.Overlay.Haskell.Dsl.Typed.Types as T +import qualified Data.Set as S import qualified Hydra.Dsl.Validation as Validation import qualified Data.Int as I @@ -39,6 +40,7 @@ tag_disabled = Tag "disabled" tag_disabledForMinimalInference = Tag "disabledForMinimalInference" +tag_disabledForScala = Tag "disabledForScala" alphaConvertRef :: TypedTerm (Name -> Name -> Term -> Term) alphaConvertRef = TypedTerm $ TermVariable $ Name "hydra.reduction.alphaConvert" @@ -77,6 +79,12 @@ checkPackageNameConventionRef :: TypedTerm (Package -> Maybe InvalidPackageError) checkPackageNameConventionRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkPackageNameConvention" +checkUndeclaredDependenciesRef :: TypedTerm (M.Map Name ModuleName -> S.Set Name -> Module -> [InvalidPackageError]) +checkUndeclaredDependenciesRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.checkUndeclaredDependencies" + +undeclaredDependencyOwnersRef :: TypedTerm ([Module] -> M.Map Name ModuleName) +undeclaredDependencyOwnersRef = TypedTerm $ TermVariable $ Name "hydra.validate.packaging.undeclaredDependencyOwners" + -- | Type checking test: infers the type and compares with expected. checkTest :: String -> [Tag] -> TypedTerm Term -> TypedTerm Term -> TypedTerm Type -> TypedTerm TestCaseWithMetadata checkTest name tags input _outputTerm outputType = testCaseWithMetadata (Phantoms.string name) @@ -270,9 +278,12 @@ typeSchemeToFTypeRef = TypedTerm $ TermVariable $ Name "hydra.scoping.typeSchemeToFType" universalCase :: String -> TypedTerm a -> TypedTerm b -> TypedTerm TestCaseWithMetadata -universalCase cname actual expected = testCaseWithMetadata (Phantoms.string cname) +universalCase cname actual expected = universalCaseWithTags cname [] actual expected + +universalCaseWithTags :: String -> [Tag] -> TypedTerm a -> TypedTerm b -> TypedTerm TestCaseWithMetadata +universalCaseWithTags cname tags actual expected = testCaseWithMetadata (Phantoms.string cname) (testCaseUniversal $ universalTestCase (retype actual) (retype expected)) - nothing noTags + nothing (Phantoms.list $ tag . unTag <$> tags) where retype :: TypedTerm x -> TypedTerm String retype (TypedTerm t) = TypedTerm t diff --git a/src/main/haskell/Hydra/Overlay/Haskell/Lib/Hashing.hs b/src/main/haskell/Hydra/Overlay/Haskell/Lib/Hashing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Overlay/Haskell/Lib/Hashing.hs @@ -0,0 +1,16 @@ +-- | Haskell implementations of hydra.lib.hashing primitives + +module Hydra.Overlay.Haskell.Lib.Hashing where + +import qualified Data.ByteString as BS +import qualified Data.ByteString.Lazy as BL +import qualified Data.Digest.Pure.SHA as SHA + + +-- | Compute the SHA-256 digest of a sequence of bytes, returning the 32-byte digest. +sha256 :: BS.ByteString -> BS.ByteString +sha256 = BL.toStrict . SHA.bytestringDigest . SHA.sha256 . BL.fromStrict + +-- | Compute the SHA-256 digest of a sequence of bytes as a 64-character lowercase hex string. +sha256Hex :: BS.ByteString -> String +sha256Hex = SHA.showDigest . SHA.sha256 . BL.fromStrict diff --git a/src/main/haskell/Hydra/Overlay/Haskell/Libraries.hs b/src/main/haskell/Hydra/Overlay/Haskell/Libraries.hs --- a/src/main/haskell/Hydra/Overlay/Haskell/Libraries.hs +++ b/src/main/haskell/Hydra/Overlay/Haskell/Libraries.hs @@ -12,6 +12,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Chars as Chars import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Overlay.Haskell.Lib.Hashing as Hashing import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic @@ -28,6 +29,7 @@ import qualified Hydra.Lib.Eithers as DefEithers import qualified Hydra.Lib.Equality as DefEquality import qualified Hydra.Lib.Files as DefFiles +import qualified Hydra.Lib.Hashing as DefHashing import qualified Hydra.Lib.Lists as DefLists import qualified Hydra.Lib.Literals as DefLiterals import qualified Hydra.Lib.Logic as DefLogic @@ -428,6 +430,11 @@ unsupportedEffectPrimitive DefSystem.getTime, unsupportedEffectPrimitive DefSystem.getWorkingDirectory] +hydraLibHashing :: Library +hydraLibHashing = standardLibrary [ + prim1 DefHashing.sha256 Hashing.sha256 [] binary binary, + prim1 DefHashing.sha256Hex Hashing.sha256Hex [] binary string] + hydraLibText :: Library hydraLibText = standardLibrary [ prim1 DefText.decodeUtf8 Text.decodeUtf8 [] binary (Prims.either_ string string), @@ -440,6 +447,7 @@ hydraLibEithers, hydraLibEquality, hydraLibFiles, + hydraLibHashing, hydraLibLists, hydraLibLiterals, hydraLibLogic, diff --git a/src/main/haskell/Hydra/Refs.hs b/src/main/haskell/Hydra/Refs.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Refs.hs @@ -0,0 +1,85 @@ +-- Note: this is an automatically generated file. Do not edit. + +-- | Typed references to derived encode/decode/show functions, and structural coder builders + +module Hydra.Refs where + +import qualified Hydra.Ast as Ast +import qualified Hydra.Coders as Coders +import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs +import qualified Hydra.Error.Checking as Checking +import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile +import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem +import qualified Hydra.Errors as Errors +import qualified Hydra.File as File +import qualified Hydra.Graph as Graph +import qualified Hydra.Json.Model as Model +import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Names as Names +import qualified Hydra.Packaging as Packaging +import qualified Hydra.Parsing as Parsing +import qualified Hydra.Paths as Paths +import qualified Hydra.Query as Query +import qualified Hydra.Relational as Relational +import qualified Hydra.System as System +import qualified Hydra.Tabular as Tabular +import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time +import qualified Hydra.Topology as Topology +import qualified Hydra.Typed as Typed +import qualified Hydra.Typing as Typing +import qualified Hydra.Util as Util +import qualified Hydra.Validation as Validation +import qualified Hydra.Variants as Variants +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S + +-- | Look up the decoder function for a type given its TypedName token +decodeRef :: Typed.TypedName t0 -> Core.Term +decodeRef tn = + Core.TermVariable (Names.derivedBindingName [ + "hydra", + "decode"] True (Typed.unTypedName tn)) + +-- | Build an encoder for a list, given an encoder for its element type +encodeList :: (t0 -> Core.Term) -> [t0] -> Core.Term +encodeList elemEncoder xs = Core.TermList (Lists.map elemEncoder xs) + +-- | Build an encoder for a map, given encoders for its key and value types +encodeMap :: Ord t0 => ((t0 -> Core.Term) -> (t1 -> Core.Term) -> M.Map t0 t1 -> Core.Term) +encodeMap keyEncoder valEncoder m = Core.TermMap (Maps.bimap keyEncoder valEncoder m) + +-- | Build an encoder for an optional value, given an encoder for its element type +encodeOptional :: (t0 -> Core.Term) -> Maybe t0 -> Core.Term +encodeOptional elemEncoder x = Core.TermOptional (Optionals.map elemEncoder x) + +-- | Build an encoder for a pair, given encoders for its first and second components +encodePair :: (t0 -> Core.Term) -> (t1 -> Core.Term) -> (t0, t1) -> Core.Term +encodePair firstEncoder secondEncoder p = Core.TermPair (Pairs.bimap firstEncoder secondEncoder p) + +-- | Look up the encoder function for a type given its TypedName token +encodeRef :: Typed.TypedName t0 -> Core.Term +encodeRef tn = + Core.TermVariable (Names.derivedBindingName [ + "hydra", + "encode"] True (Typed.unTypedName tn)) + +-- | Build an encoder for a set, given an encoder for its element type +encodeSet :: Ord t0 => ((t0 -> Core.Term) -> S.Set t0 -> Core.Term) +encodeSet elemEncoder xs = Core.TermSet (Sets.map elemEncoder xs) + +-- | Look up the string-shower function for a type given its TypedName token +showRef :: Typed.TypedName t0 -> Core.Term +showRef tn = + Core.TermVariable (Names.derivedBindingName [ + "hydra", + "show"] True (Typed.unTypedName tn)) diff --git a/src/main/haskell/Hydra/Show/Error/Packaging.hs b/src/main/haskell/Hydra/Show/Error/Packaging.hs --- a/src/main/haskell/Hydra/Show/Error/Packaging.hs +++ b/src/main/haskell/Hydra/Show/Error/Packaging.hs @@ -134,7 +134,8 @@ ErrorPackaging.InvalidPackageErrorConflictingModuleName v0 -> conflictingModuleNameError v0 ErrorPackaging.InvalidPackageErrorDuplicateModuleName v0 -> duplicateModuleNameError v0 ErrorPackaging.InvalidPackageErrorInvalidModule v0 -> invalidModuleError v0 - ErrorPackaging.InvalidPackageErrorInvalidPackageName v0 -> invalidPackageNameError v0) + ErrorPackaging.InvalidPackageErrorInvalidPackageName v0 -> invalidPackageNameError v0 + ErrorPackaging.InvalidPackageErrorUndeclaredDependency v0 -> undeclaredDependencyError v0) -- | Show an invalid package name error as a string invalidPackageNameError :: ErrorPackaging.InvalidPackageNameError -> String @@ -153,3 +154,15 @@ ": definition ", (Core.unName (ErrorPackaging.missingDocumentationErrorName e)), " lacks a description annotation"] + +-- | Show an undeclared dependency error as a string +undeclaredDependencyError :: ErrorPackaging.UndeclaredDependencyError -> String +undeclaredDependencyError e = + Strings.cat [ + "module ", + (Packaging.unModuleName (ErrorPackaging.undeclaredDependencyErrorModuleName e)), + " references ", + (Core.unName (ErrorPackaging.undeclaredDependencyErrorReferencedName e)), + ", whose owning module ", + (Packaging.unModuleName (ErrorPackaging.undeclaredDependencyErrorOwningModuleName e)), + " is not among its declared dependencies; add it to moduleDependencies"] diff --git a/src/main/haskell/Hydra/Typed.hs b/src/main/haskell/Hydra/Typed.hs --- a/src/main/haskell/Hydra/Typed.hs +++ b/src/main/haskell/Hydra/Typed.hs @@ -23,6 +23,14 @@ _TypedBinding_term = Core.Name "term" +-- | An association of a name with a phantom type +newtype TypedName a = + TypedName { + unTypedName :: Core.Name} + deriving (Eq, Ord, Read, Show) + +_TypedName = Core.Name "hydra.typed.TypedName" + -- | An association of a term with a phantom type newtype TypedTerm a = TypedTerm { diff --git a/src/main/haskell/Hydra/Validate/Core.hs b/src/main/haskell/Hydra/Validate/Core.hs --- a/src/main/haskell/Hydra/Validate/Core.hs +++ b/src/main/haskell/Hydra/Validate/Core.hs @@ -251,7 +251,8 @@ checkUndefinedTypeVariablesInType path cx typ mkError = let freeVars = Variables.freeVariablesInType typ - undefined = Sets.difference freeVars (Graph.graphTypeVariables cx) + resolvedNames = Sets.union (Graph.graphTypeVariables cx) (Sets.fromList (Maps.keys (Graph.graphSchemaTypes cx))) + undefined = Sets.difference freeVars resolvedNames in (Optionals.cases (Lists.maybeHead (Sets.toList undefined)) Nothing (\firstUndefined -> mkError firstUndefined)) -- | Check a type scheme for type variables not bound by the scheme or the current scope @@ -259,7 +260,8 @@ checkUndefinedTypeVariablesInTypeScheme path cx ts mkError = let freeVars = Variables.freeVariablesInTypeScheme ts - undefined = Sets.difference freeVars (Graph.graphTypeVariables cx) + resolvedNames = Sets.union (Graph.graphTypeVariables cx) (Sets.fromList (Maps.keys (Graph.graphSchemaTypes cx))) + undefined = Sets.difference freeVars resolvedNames in (Optionals.cases (Lists.maybeHead (Sets.toList undefined)) Nothing (\firstUndefined -> mkError firstUndefined)) -- | Return an error if the given type is TypeVoid diff --git a/src/main/haskell/Hydra/Validate/Packaging.hs b/src/main/haskell/Hydra/Validate/Packaging.hs --- a/src/main/haskell/Hydra/Validate/Packaging.hs +++ b/src/main/haskell/Hydra/Validate/Packaging.hs @@ -9,6 +9,7 @@ import qualified Hydra.Coders as Coders import qualified Hydra.Constants as Constants import qualified Hydra.Core as Core +import qualified Hydra.Dependencies as Dependencies import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore @@ -44,9 +45,12 @@ import qualified Hydra.Typing as Typing import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation +import qualified Hydra.Variables as Variables import qualified Hydra.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci +import qualified Data.Map as M +import qualified Data.Set as S -- | Append a rule-tagged InvalidModuleError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds. appendFindingModule :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0 @@ -257,6 +261,26 @@ in (Logic.ifElse (Regex.matches Constants.regexPackageName (Packaging.unPackageName pname)) Nothing (Just (ErrorPackaging.InvalidPackageErrorInvalidPackageName (ErrorPackaging.InvalidPackageNameError { ErrorPackaging.invalidPackageNameErrorPackageName = pname})))) +-- | Check a module's definitions for free names whose owning module is not among its declared dependencies +checkUndeclaredDependencies :: M.Map Core.Name Packaging.ModuleName -> S.Set Core.Name -> Packaging.Module -> [ErrorPackaging.InvalidPackageError] +checkUndeclaredDependencies owners primNames mod = + + let ns = Packaging.moduleName mod + visible = + Sets.insert ns (Sets.fromList (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod))) + referencedNames = + \def -> case def of + Packaging.DefinitionTerm v0 -> Sets.union (Variables.freeVariablesInTerm (Packaging.termDefinitionBody v0)) (Dependencies.termDependencyNames False False True (Packaging.termDefinitionBody v0)) + Packaging.DefinitionType v0 -> Dependencies.typeDependencyNames False (Core.typeSchemeBody (Packaging.typeDefinitionBody v0)) + _ -> Sets.empty + findingForRef = + \refName -> Logic.ifElse (Sets.member refName primNames) Nothing (Optionals.bind (Maps.lookup refName owners) (\owner -> Logic.ifElse (Sets.member owner visible) Nothing (Just (ErrorPackaging.InvalidPackageErrorUndeclaredDependency (ErrorPackaging.UndeclaredDependencyError { + ErrorPackaging.undeclaredDependencyErrorModuleName = ns, + ErrorPackaging.undeclaredDependencyErrorReferencedName = refName, + ErrorPackaging.undeclaredDependencyErrorOwningModuleName = owner}))))) + findingsForDef = \def -> Optionals.mapOptional findingForRef (Sets.toList (referencedNames def)) + in (Lists.concat (Lists.map findingsForDef (Packaging.moduleDefinitions mod))) + -- | Extract the name from a definition definitionName :: Packaging.Definition -> Core.Name definitionName def = @@ -303,6 +327,32 @@ Validation.validationResultErrors = [], Validation.validationResultWarnings = []}) pkg)) +-- | Non-kernel packaging profile (#575): identical to kernelDefaultPackagingProfile except the rules in kernelPackagingWarningRuleNamesForNonKernel (documentation, ordering, naming convention) are warnings, not errors, so each package's pre-existing backlog does not block sync until that package is promoted to the fully-fatal profile. +kernelPackagingProfileWithDocWarnings :: Validation.ValidationProfile +kernelPackagingProfileWithDocWarnings = + Validation.ValidationProfile { + Validation.validationProfileErrorRules = (Sets.fromList [ + Core.Name "hydra.error.packaging.InvalidModuleError.conflictingVariantName", + (Core.Name "hydra.error.packaging.InvalidModuleError.definitionNotInModuleName"), + (Core.Name "hydra.error.packaging.InvalidModuleError.duplicateDefinitionName"), + (Core.Name "hydra.error.packaging.InvalidModuleError.invalidModuleNameConvention"), + (Core.Name "hydra.error.packaging.InvalidPackageError.conflictingModuleName"), + (Core.Name "hydra.error.packaging.InvalidPackageError.duplicateModuleName"), + (Core.Name "hydra.error.packaging.InvalidPackageError.invalidPackageName")]), + Validation.validationProfileWarningRules = (Sets.fromList [ + Core.Name "hydra.error.packaging.InvalidModuleError.missingDocumentation", + (Core.Name "hydra.error.packaging.InvalidModuleError.definitionsOutOfOrder"), + (Core.Name "hydra.error.packaging.InvalidModuleError.invalidDefinitionName")]), + Validation.validationProfileMaxErrors = 1, + Validation.validationProfileMaxWarnings = 10000} + +-- | Check every module in the given universe for undeclared cross-module dependencies, returning every finding. +kernelUniverseUndeclaredDependencies :: [Packaging.Module] -> S.Set Core.Name -> [ErrorPackaging.InvalidPackageError] +kernelUniverseUndeclaredDependencies universe primNames = + + let owners = undeclaredDependencyOwners universe + in (Lists.concat (Lists.map (\mod -> checkUndeclaredDependencies owners primNames mod) universe)) + -- | Validate a module against the given ValidationProfile, accumulating findings into a ValidationResult. Errors hard-stop the rule sequence once maxErrors is reached. module_ :: Validation.ValidationProfile -> Validation.ValidationResult ErrorPackaging.InvalidModuleError -> Packaging.Module -> Validation.ValidationResult ErrorPackaging.InvalidModuleError module_ p acc0 mod = @@ -338,3 +388,8 @@ in Validation.ValidationResult { Validation.validationResultErrors = newErrs, Validation.validationResultWarnings = newWrns})) accPkg (Packaging.packageModules pkg)) + +-- | Build a map from every name defined in the universe to its owning module +undeclaredDependencyOwners :: [Packaging.Module] -> M.Map Core.Name Packaging.ModuleName +undeclaredDependencyOwners universe = + Maps.fromList (Lists.concat (Lists.map (\m -> Lists.map (\def -> (definitionName def, (Packaging.moduleName m))) (Packaging.moduleDefinitions m)) universe))